home *** CD-ROM | disk | FTP | other *** search
/ Turnbull China Bikeride / Turnbull China Bikeride - Disc 2.iso / BARNET / ARMTEX / SOURCES2 / !TeX / texmf / source / armTeX / web / c / tangle
Encoding:
Text File  |  1998-04-04  |  67.7 KB  |  3,204 lines
  1. #include "h.config"
  2. /* 9999 */ 
  3. #define bufsize 100 
  4. #define maxbytes 45000L 
  5. #define maxtoks 50000L 
  6. #define maxnames 4000 
  7. #define maxtexts 2000 
  8. #define hashsize 353 
  9. #define longestname 400 
  10. #define linelength 72 
  11. #define outbufsize 144 
  12. #define stacksize 100 
  13. #define maxidlength 50 
  14. #define unambiglength 20 
  15. typedef unsigned char ASCIIcode  ; 
  16. typedef file_ptr /* of  ASCIIcode */ textfile  ; 
  17. typedef unsigned char eightbits  ; 
  18. typedef integer sixteenbits  ; 
  19. typedef integer namepointer  ; 
  20. typedef integer textpointer  ; 
  21. typedef struct {
  22.     sixteenbits endfield ; 
  23.   sixteenbits bytefield ; 
  24.   namepointer namefield ; 
  25.   textpointer replfield ; 
  26.   integer modfield ; 
  27. } outputstate  ; 
  28. char history  ; 
  29. ASCIIcode xord[256]  ; 
  30. ASCIIcode xchr[256]  ; 
  31. textfile webfile  ; 
  32. textfile changefile  ; 
  33. textfile Pascalfile  ; 
  34. textfile pool  ; 
  35. ASCIIcode buffer[bufsize + 1]  ; 
  36. boolean phaseone  ; 
  37. ASCIIcode bytemem[3][maxbytes + 1]  ; 
  38. eightbits tokmem[4][maxtoks + 1]  ; 
  39. sixteenbits bytestart[maxnames + 1]  ; 
  40. sixteenbits tokstart[maxtexts + 1]  ; 
  41. sixteenbits link[maxnames + 1]  ; 
  42. sixteenbits ilk[maxnames + 1]  ; 
  43. sixteenbits equiv[maxnames + 1]  ; 
  44. sixteenbits textlink[maxtexts + 1]  ; 
  45. namepointer nameptr  ; 
  46. namepointer stringptr  ; 
  47. integer byteptr[3]  ; 
  48. integer poolchecksum  ; 
  49. textpointer textptr  ; 
  50. integer tokptr[4]  ; 
  51. char z  ; 
  52. integer idfirst  ; 
  53. integer idloc  ; 
  54. integer doublechars  ; 
  55. sixteenbits hash[hashsize + 1], chophash[hashsize + 1]  ; 
  56. ASCIIcode choppedid[unambiglength + 1]  ; 
  57. ASCIIcode modtext[longestname + 1]  ; 
  58. textpointer lastunnamed  ; 
  59. outputstate curstate  ; 
  60. outputstate stack[stacksize + 1]  ; 
  61. integer stackptr  ; 
  62. char zo  ; 
  63. eightbits bracelevel  ; 
  64. integer curval  ; 
  65. ASCIIcode outbuf[outbufsize + 1]  ; 
  66. integer outptr  ; 
  67. integer breakptr  ; 
  68. integer semiptr  ; 
  69. eightbits outstate  ; 
  70. integer outval, outapp  ; 
  71. ASCIIcode outsign  ; 
  72. schar lastsign  ; 
  73. ASCIIcode outcontrib[linelength + 1]  ; 
  74. integer ii  ; 
  75. integer line  ; 
  76. integer otherline  ; 
  77. integer templine  ; 
  78. integer limit  ; 
  79. integer loc  ; 
  80. boolean inputhasended  ; 
  81. boolean changing  ; 
  82. ASCIIcode changebuffer[bufsize + 1]  ; 
  83. integer changelimit  ; 
  84. namepointer curmodule  ; 
  85. boolean scanninghex  ; 
  86. eightbits nextcontrol  ; 
  87. textpointer currepltext  ; 
  88. integer modulecount  ; 
  89. char webname[PATHMAX + 1], chgname[PATHMAX + 1], pascalfilename[PATHMAX + 1], 
  90. poolfilename[PATHMAX + 1]  ; 
  91.  
  92. #include "h.tangle"
  93. void error ( ) 
  94. {integer j  ; 
  95.   integer k, l  ; 
  96.   if ( phaseone ) 
  97.   {
  98.     if ( changing ) 
  99.     Fputs( stdout ,  ". (change file " ) ; 
  100.     else
  101.     Fputs( stdout ,  ". (" ) ; 
  102.     fprintf( stdout , "%s%ld%c\n",  "l." , (long)line , ')' ) ; 
  103.     if ( loc >= limit ) 
  104.     l = limit ; 
  105.     else l = loc ; 
  106.     {register integer for_end; k = 1 ; for_end = l ; if ( k <= for_end) do 
  107.       if ( buffer [ k - 1 ] == 9 ) 
  108.       putc ( ' ' ,  stdout );
  109.       else
  110.       putc ( xchr [ buffer [ k - 1 ] ] ,  stdout );
  111.     while ( k++ < for_end ) ; } 
  112.     putc ('\n',  stdout );
  113.     {register integer for_end; k = 1 ; for_end = l ; if ( k <= for_end) do 
  114.       putc ( ' ' ,  stdout );
  115.     while ( k++ < for_end ) ; } 
  116.     {register integer for_end; k = l + 1 ; for_end = limit ; if ( k <= 
  117.     for_end) do 
  118.       putc ( xchr [ buffer [ k - 1 ] ] ,  stdout );
  119.     while ( k++ < for_end ) ; } 
  120.     putc ( ' ' ,  stdout );
  121.   } 
  122.   else {
  123.       
  124.     fprintf( stdout , "%s%ld%c\n",  ". (l." , (long)line , ')' ) ; 
  125.     {register integer for_end; j = 1 ; for_end = outptr ; if ( j <= for_end) 
  126.     do 
  127.       putc ( xchr [ outbuf [ j - 1 ] ] ,  stdout );
  128.     while ( j++ < for_end ) ; } 
  129.     Fputs( stdout ,  "... " ) ; 
  130.   } 
  131.   flush ( stdout ) ; 
  132.   history = 2 ; 
  133. } 
  134. void scanargs ( ) 
  135. {integer dotpos, slashpos, i, a  ; 
  136.   char c  ; 
  137.   char fname[PATHMAX + 1]  ; 
  138.   boolean foundweb, foundchange  ; 
  139.   foundweb = false ; 
  140.   foundchange = false ; 
  141.   {register integer for_end; a = 1 ; for_end = argc - 1 ; if ( a <= for_end) 
  142.   do 
  143.     {
  144.       argv ( a , fname ) ; 
  145.       if ( fname [ 1 ] != '-' ) 
  146.       {
  147.     if ( ! foundweb ) 
  148.     {
  149.       dotpos = -1 ; 
  150.       slashpos = -1 ; 
  151.       i = 1 ; 
  152.       while ( ( fname [ i ] != ' ' ) && ( i <= PATHMAX - 5 ) ) {
  153.           
  154.         webname [ i ] = fname [ i ] ; 
  155.         if ( fname [ i ] == '.' ) 
  156.         dotpos = i ; 
  157.         if ( fname [ i ] == '/' ) 
  158.         slashpos = i ; 
  159.         i = i + 1 ; 
  160.       } 
  161.       webname [ i ] = ' ' ; 
  162.       if ( ( dotpos == -1 ) || ( dotpos < slashpos ) ) 
  163.       {
  164.         dotpos = i ; 
  165.         webname [ dotpos ] = '.' ; 
  166.         webname [ dotpos + 1 ] = 'w' ; 
  167.         webname [ dotpos + 2 ] = 'e' ; 
  168.         webname [ dotpos + 3 ] = 'b' ; 
  169.         webname [ dotpos + 4 ] = ' ' ; 
  170.       } 
  171.       {register integer for_end; i = 1 ; for_end = dotpos ; if ( i <= 
  172.       for_end) do 
  173.         {
  174.           c = webname [ i ] ; 
  175.           pascalfilename [ i ] = c ; 
  176.           poolfilename [ i ] = c ; 
  177.         } 
  178.       while ( i++ < for_end ) ; } 
  179.       pascalfilename [ dotpos + 1 ] = 'p' ; 
  180.       pascalfilename [ dotpos + 2 ] = ' ' ; 
  181.       poolfilename [ dotpos + 1 ] = 'p' ; 
  182.       poolfilename [ dotpos + 2 ] = 'o' ; 
  183.       poolfilename [ dotpos + 3 ] = 'o' ; 
  184.       poolfilename [ dotpos + 4 ] = 'l' ; 
  185.       poolfilename [ dotpos + 5 ] = ' ' ; 
  186.       foundweb = true ; 
  187.     } 
  188.     else if ( ! foundchange ) 
  189.     {
  190.       dotpos = -1 ; 
  191.       slashpos = -1 ; 
  192.       i = 1 ; 
  193.       while ( ( fname [ i ] != ' ' ) && ( i <= PATHMAX - 5 ) ) {
  194.           
  195.         chgname [ i ] = fname [ i ] ; 
  196.         if ( fname [ i ] == '.' ) 
  197.         dotpos = i ; 
  198.         if ( fname [ i ] == '/' ) 
  199.         slashpos = i ; 
  200.         i = i + 1 ; 
  201.       } 
  202.       chgname [ i ] = ' ' ; 
  203.       if ( ( dotpos == -1 ) || ( dotpos < slashpos ) ) 
  204.       {
  205.         dotpos = i ; 
  206.         chgname [ dotpos ] = '.' ; 
  207.         chgname [ dotpos + 1 ] = 'c' ; 
  208.         chgname [ dotpos + 2 ] = 'h' ; 
  209.         chgname [ dotpos + 3 ] = ' ' ; 
  210.       } 
  211.       foundchange = true ; 
  212.     } 
  213.     else {
  214.         
  215.       fprintf( stdout , "%s\n",            "Usage: tangle webfile[.web] [changefile[.ch]] [-o file] [-p poolfile]"           ) ; 
  216.       uexit ( 1 ) ; 
  217.     } 
  218.       } 
  219.       else {
  220.       
  221.     if ( fname [ 2 ] == 'o' ) 
  222.     {
  223.       a = a + 1 ; 
  224.       argv ( a , pascalfilename ) ; 
  225.     } 
  226.     else if ( fname [ 2 ] == 'p' ) 
  227.     {
  228.       a = a + 1 ; 
  229.       argv ( a , poolfilename ) ; 
  230.     } 
  231.     else {
  232.         
  233.       fprintf( stdout , "%s\n",            "Usage: tangle webfile[.web] [changefile[.ch]] [-o file] [-p poolfile]"           ) ; 
  234.       uexit ( 1 ) ; 
  235.     } 
  236.       } 
  237.     } 
  238.   while ( a++ < for_end ) ; } 
  239.   if ( ! foundweb ) 
  240.   {
  241.     fprintf( stdout , "%s\n",      "Usage: tangle webfile[.web] [changefile[.ch]] [-o file] [-p poolfile]" ) 
  242.     ; 
  243.     uexit ( 1 ) ; 
  244.   } 
  245.   if ( ! foundchange ) 
  246.   {
  247.     chgname [ 1 ] = 'n' ; 
  248.     chgname [ 2 ] = 'u' ; 
  249.     chgname [ 3 ] = 'l' ; 
  250.     chgname [ 4 ] = 'l' ; 
  251.     chgname [ 5 ] = ':' ; 
  252.     chgname [ 6 ] = ' ' ; 
  253.   } 
  254. } 
  255. void initialize ( ) 
  256. {unsigned char i  ; 
  257.   char wi  ; 
  258.   char zi  ; 
  259.   integer h  ; 
  260.   history = 0 ; 
  261.   xchr [ 32 ] = ' ' ; 
  262.   xchr [ 33 ] = '!' ; 
  263.   xchr [ 34 ] = '"' ; 
  264.   xchr [ 35 ] = '#' ; 
  265.   xchr [ 36 ] = '$' ; 
  266.   xchr [ 37 ] = '%' ; 
  267.   xchr [ 38 ] = '&' ; 
  268.   xchr [ 39 ] = '\'' ; 
  269.   xchr [ 40 ] = '(' ; 
  270.   xchr [ 41 ] = ')' ; 
  271.   xchr [ 42 ] = '*' ; 
  272.   xchr [ 43 ] = '+' ; 
  273.   xchr [ 44 ] = ',' ; 
  274.   xchr [ 45 ] = '-' ; 
  275.   xchr [ 46 ] = '.' ; 
  276.   xchr [ 47 ] = '/' ; 
  277.   xchr [ 48 ] = '0' ; 
  278.   xchr [ 49 ] = '1' ; 
  279.   xchr [ 50 ] = '2' ; 
  280.   xchr [ 51 ] = '3' ; 
  281.   xchr [ 52 ] = '4' ; 
  282.   xchr [ 53 ] = '5' ; 
  283.   xchr [ 54 ] = '6' ; 
  284.   xchr [ 55 ] = '7' ; 
  285.   xchr [ 56 ] = '8' ; 
  286.   xchr [ 57 ] = '9' ; 
  287.   xchr [ 58 ] = ':' ; 
  288.   xchr [ 59 ] = ';' ; 
  289.   xchr [ 60 ] = '<' ; 
  290.   xchr [ 61 ] = '=' ; 
  291.   xchr [ 62 ] = '>' ; 
  292.   xchr [ 63 ] = '?' ; 
  293.   xchr [ 64 ] = '@' ; 
  294.   xchr [ 65 ] = 'A' ; 
  295.   xchr [ 66 ] = 'B' ; 
  296.   xchr [ 67 ] = 'C' ; 
  297.   xchr [ 68 ] = 'D' ; 
  298.   xchr [ 69 ] = 'E' ; 
  299.   xchr [ 70 ] = 'F' ; 
  300.   xchr [ 71 ] = 'G' ; 
  301.   xchr [ 72 ] = 'H' ; 
  302.   xchr [ 73 ] = 'I' ; 
  303.   xchr [ 74 ] = 'J' ; 
  304.   xchr [ 75 ] = 'K' ; 
  305.   xchr [ 76 ] = 'L' ; 
  306.   xchr [ 77 ] = 'M' ; 
  307.   xchr [ 78 ] = 'N' ; 
  308.   xchr [ 79 ] = 'O' ; 
  309.   xchr [ 80 ] = 'P' ; 
  310.   xchr [ 81 ] = 'Q' ; 
  311.   xchr [ 82 ] = 'R' ; 
  312.   xchr [ 83 ] = 'S' ; 
  313.   xchr [ 84 ] = 'T' ; 
  314.   xchr [ 85 ] = 'U' ; 
  315.   xchr [ 86 ] = 'V' ; 
  316.   xchr [ 87 ] = 'W' ; 
  317.   xchr [ 88 ] = 'X' ; 
  318.   xchr [ 89 ] = 'Y' ; 
  319.   xchr [ 90 ] = 'Z' ; 
  320.   xchr [ 91 ] = '[' ; 
  321.   xchr [ 92 ] = '\\' ; 
  322.   xchr [ 93 ] = ']' ; 
  323.   xchr [ 94 ] = '^' ; 
  324.   xchr [ 95 ] = '_' ; 
  325.   xchr [ 96 ] = '`' ; 
  326.   xchr [ 97 ] = 'a' ; 
  327.   xchr [ 98 ] = 'b' ; 
  328.   xchr [ 99 ] = 'c' ; 
  329.   xchr [ 100 ] = 'd' ; 
  330.   xchr [ 101 ] = 'e' ; 
  331.   xchr [ 102 ] = 'f' ; 
  332.   xchr [ 103 ] = 'g' ; 
  333.   xchr [ 104 ] = 'h' ; 
  334.   xchr [ 105 ] = 'i' ; 
  335.   xchr [ 106 ] = 'j' ; 
  336.   xchr [ 107 ] = 'k' ; 
  337.   xchr [ 108 ] = 'l' ; 
  338.   xchr [ 109 ] = 'm' ; 
  339.   xchr [ 110 ] = 'n' ; 
  340.   xchr [ 111 ] = 'o' ; 
  341.   xchr [ 112 ] = 'p' ; 
  342.   xchr [ 113 ] = 'q' ; 
  343.   xchr [ 114 ] = 'r' ; 
  344.   xchr [ 115 ] = 's' ; 
  345.   xchr [ 116 ] = 't' ; 
  346.   xchr [ 117 ] = 'u' ; 
  347.   xchr [ 118 ] = 'v' ; 
  348.   xchr [ 119 ] = 'w' ; 
  349.   xchr [ 120 ] = 'x' ; 
  350.   xchr [ 121 ] = 'y' ; 
  351.   xchr [ 122 ] = 'z' ; 
  352.   xchr [ 123 ] = '{' ; 
  353.   xchr [ 124 ] = '|' ; 
  354.   xchr [ 125 ] = '}' ; 
  355.   xchr [ 126 ] = '~' ; 
  356.   xchr [ 0 ] = ' ' ; 
  357.   xchr [ 127 ] = ' ' ; 
  358.   {register integer for_end; i = 1 ; for_end = 31 ; if ( i <= for_end) do 
  359.     xchr [ i ] = chr ( i ) ; 
  360.   while ( i++ < for_end ) ; } 
  361.   {register integer for_end; i = 128 ; for_end = 255 ; if ( i <= for_end) do 
  362.     xchr [ i ] = chr ( i ) ; 
  363.   while ( i++ < for_end ) ; } 
  364.   {register integer for_end; i = 0 ; for_end = 255 ; if ( i <= for_end) do 
  365.     xord [ chr ( i ) ] = 32 ; 
  366.   while ( i++ < for_end ) ; } 
  367.   {register integer for_end; i = 1 ; for_end = 255 ; if ( i <= for_end) do 
  368.     xord [ xchr [ i ] ] = i ; 
  369.   while ( i++ < for_end ) ; } 
  370.   xord [ ' ' ] = 32 ; 
  371.   scanargs () ; 
  372.   rewrite ( Pascalfile , pascalfilename ) ; 
  373.   {register integer for_end; wi = 0 ; for_end = 2 ; if ( wi <= for_end) do 
  374.     {
  375.       bytestart [ wi ] = 0 ; 
  376.       byteptr [ wi ] = 0 ; 
  377.     } 
  378.   while ( wi++ < for_end ) ; } 
  379.   bytestart [ 3 ] = 0 ; 
  380.   nameptr = 1 ; 
  381.   stringptr = 256 ; 
  382.   poolchecksum = 271828L ; 
  383.   {register integer for_end; zi = 0 ; for_end = 3 ; if ( zi <= for_end) do 
  384.     {
  385.       tokstart [ zi ] = 0 ; 
  386.       tokptr [ zi ] = 0 ; 
  387.     } 
  388.   while ( zi++ < for_end ) ; } 
  389.   tokstart [ 4 ] = 0 ; 
  390.   textptr = 1 ; 
  391.   z = 1 % 4 ; 
  392.   ilk [ 0 ] = 0 ; 
  393.   equiv [ 0 ] = 0 ; 
  394.   {register integer for_end; h = 0 ; for_end = hashsize - 1 ; if ( h <= 
  395.   for_end) do 
  396.     {
  397.       hash [ h ] = 0 ; 
  398.       chophash [ h ] = 0 ; 
  399.     } 
  400.   while ( h++ < for_end ) ; } 
  401.   lastunnamed = 0 ; 
  402.   textlink [ 0 ] = 0 ; 
  403.   scanninghex = false ; 
  404.   modtext [ 0 ] = 32 ; 
  405. } 
  406. void openinput ( ) 
  407. {reset ( webfile , webname ) ; 
  408.   reset ( changefile , chgname ) ; 
  409. } 
  410. boolean zinputln ( f ) 
  411. textfile f ; 
  412. {register boolean Result; integer finallimit  ; 
  413.   limit = 0 ; 
  414.   finallimit = 0 ; 
  415.   if ( eof ( f ) ) 
  416.   Result = false ; 
  417.   else {
  418.       
  419.     while ( ! eoln ( f ) ) {
  420.     
  421.       buffer [ limit ] = xord [ getc ( f ) ] ; 
  422.       limit = limit + 1 ; 
  423.       if ( buffer [ limit - 1 ] != 32 ) 
  424.       finallimit = limit ; 
  425.       if ( limit == bufsize ) 
  426.       {
  427.     while ( ! eoln ( f ) ) vgetc ( f ) ; 
  428.     limit = limit - 1 ; 
  429.     if ( finallimit > limit ) 
  430.     finallimit = limit ; 
  431.     {
  432.       putc ('\n',  stdout );
  433.       Fputs( stdout ,  "! Input line too long" ) ; 
  434.     } 
  435.     loc = 0 ; 
  436.     error () ; 
  437.       } 
  438.     } 
  439.     readln ( f ) ; 
  440.     limit = finallimit ; 
  441.     Result = true ; 
  442.   } 
  443.   return(Result) ; 
  444. } 
  445. void zprintid ( p ) 
  446. namepointer p ; 
  447. {integer k  ; 
  448.   char w  ; 
  449.   if ( p >= nameptr ) 
  450.   Fputs( stdout ,  "IMPOSSIBLE" ) ; 
  451.   else {
  452.       
  453.     w = p % 3 ; 
  454.     {register integer for_end; k = bytestart [ p ] ; for_end = bytestart [ p 
  455.     + 3 ] - 1 ; if ( k <= for_end) do 
  456.       putc ( xchr [ bytemem [ w ][ k ] ] ,  stdout );
  457.     while ( k++ < for_end ) ; } 
  458.   } 
  459. } 
  460. namepointer zidlookup ( t ) 
  461. eightbits t ; 
  462. {/* 31 32 */ register namepointer Result; eightbits c  ; 
  463.   integer i  ; 
  464.   integer h  ; 
  465.   integer k  ; 
  466.   char w  ; 
  467.   integer l  ; 
  468.   namepointer p, q  ; 
  469.   integer s  ; 
  470.   l = idloc - idfirst ; 
  471.   h = buffer [ idfirst ] ; 
  472.   i = idfirst + 1 ; 
  473.   while ( i < idloc ) {
  474.       
  475.     h = ( h + h + buffer [ i ] ) % hashsize ; 
  476.     i = i + 1 ; 
  477.   } 
  478.   p = hash [ h ] ; 
  479.   while ( p != 0 ) {
  480.       
  481.     if ( bytestart [ p + 3 ] - bytestart [ p ] == l ) 
  482.     {
  483.       i = idfirst ; 
  484.       k = bytestart [ p ] ; 
  485.       w = p % 3 ; 
  486.       while ( ( i < idloc ) && ( buffer [ i ] == bytemem [ w ][ k ] ) ) {
  487.       
  488.     i = i + 1 ; 
  489.     k = k + 1 ; 
  490.       } 
  491.       if ( i == idloc ) 
  492.       goto lab31 ; 
  493.     } 
  494.     p = link [ p ] ; 
  495.   } 
  496.   p = nameptr ; 
  497.   link [ p ] = hash [ h ] ; 
  498.   hash [ h ] = p ; 
  499.   lab31: ; 
  500.   if ( ( p == nameptr ) || ( t != 0 ) ) 
  501.   {
  502.     if ( ( ( p != nameptr ) && ( t != 0 ) && ( ilk [ p ] == 0 ) ) || ( ( p == 
  503.     nameptr ) && ( t == 0 ) && ( buffer [ idfirst ] != 34 ) ) ) 
  504.     {
  505.       i = idfirst ; 
  506.       s = 0 ; 
  507.       h = 0 ; 
  508.       while ( ( i < idloc ) && ( s < unambiglength ) ) {
  509.       
  510.     if ( buffer [ i ] != 95 ) 
  511.     {
  512.       if ( buffer [ i ] >= 97 ) 
  513.       choppedid [ s ] = buffer [ i ] - 32 ; 
  514.       else choppedid [ s ] = buffer [ i ] ; 
  515.       h = ( h + h + choppedid [ s ] ) % hashsize ; 
  516.       s = s + 1 ; 
  517.     } 
  518.     i = i + 1 ; 
  519.       } 
  520.       choppedid [ s ] = 0 ; 
  521.     } 
  522.     if ( p != nameptr ) 
  523.     {
  524.       if ( ilk [ p ] == 0 ) 
  525.       {
  526.     if ( t == 1 ) 
  527.     {
  528.       putc ('\n',  stdout );
  529.       Fputs( stdout ,  "! This identifier has already appeared" ) ; 
  530.       error () ; 
  531.     } 
  532.     q = chophash [ h ] ; 
  533.     if ( q == p ) 
  534.     chophash [ h ] = equiv [ p ] ; 
  535.     else {
  536.         
  537.       while ( equiv [ q ] != p ) q = equiv [ q ] ; 
  538.       equiv [ q ] = equiv [ p ] ; 
  539.     } 
  540.       } 
  541.       else {
  542.       
  543.     putc ('\n',  stdout );
  544.     Fputs( stdout ,  "! This identifier was defined before" ) ; 
  545.     error () ; 
  546.       } 
  547.       ilk [ p ] = t ; 
  548.     } 
  549.     else {
  550.     
  551.       if ( ( t == 0 ) && ( buffer [ idfirst ] != 34 ) ) 
  552.       {
  553.     q = chophash [ h ] ; 
  554.     while ( q != 0 ) {
  555.         
  556.       {
  557.         k = bytestart [ q ] ; 
  558.         s = 0 ; 
  559.         w = q % 3 ; 
  560.         while ( ( k < bytestart [ q + 3 ] ) && ( s < unambiglength ) ) {
  561.         
  562.           c = bytemem [ w ][ k ] ; 
  563.           if ( c != 95 ) 
  564.           {
  565.         if ( choppedid [ s ] != c ) 
  566.         goto lab32 ; 
  567.         s = s + 1 ; 
  568.           } 
  569.           k = k + 1 ; 
  570.         } 
  571.         if ( ( k == bytestart [ q + 3 ] ) && ( choppedid [ s ] != 0 ) ) 
  572.         goto lab32 ; 
  573.         {
  574.           putc ('\n',  stdout );
  575.           Fputs( stdout ,  "! Identifier conflict with " ) ; 
  576.         } 
  577.         {register integer for_end; k = bytestart [ q ] ; for_end = 
  578.         bytestart [ q + 3 ] - 1 ; if ( k <= for_end) do 
  579.           putc ( xchr [ bytemem [ w ][ k ] ] ,  stdout );
  580.         while ( k++ < for_end ) ; } 
  581.         error () ; 
  582.         q = 0 ; 
  583.         lab32: ; 
  584.       } 
  585.       q = equiv [ q ] ; 
  586.     } 
  587.     equiv [ p ] = chophash [ h ] ; 
  588.     chophash [ h ] = p ; 
  589.       } 
  590.       w = nameptr % 3 ; 
  591.       k = byteptr [ w ] ; 
  592.       if ( k + l > maxbytes ) 
  593.       {
  594.     putc ('\n',  stdout );
  595.     fprintf( stdout , "%s%s%s",  "! Sorry, " , "byte memory" , " capacity exceeded" ) 
  596.     ; 
  597.     error () ; 
  598.     history = 3 ; 
  599.     uexit ( 1 ) ; 
  600.       } 
  601.       if ( nameptr > maxnames - 3 ) 
  602.       {
  603.     putc ('\n',  stdout );
  604.     fprintf( stdout , "%s%s%s",  "! Sorry, " , "name" , " capacity exceeded" ) ; 
  605.     error () ; 
  606.     history = 3 ; 
  607.     uexit ( 1 ) ; 
  608.       } 
  609.       i = idfirst ; 
  610.       while ( i < idloc ) {
  611.       
  612.     bytemem [ w ][ k ] = buffer [ i ] ; 
  613.     k = k + 1 ; 
  614.     i = i + 1 ; 
  615.       } 
  616.       byteptr [ w ] = k ; 
  617.       bytestart [ nameptr + 3 ] = k ; 
  618.       nameptr = nameptr + 1 ; 
  619.       if ( buffer [ idfirst ] != 34 ) 
  620.       ilk [ p ] = t ; 
  621.       else {
  622.       
  623.     ilk [ p ] = 1 ; 
  624.     if ( l - doublechars == 2 ) 
  625.     equiv [ p ] = buffer [ idfirst + 1 ] + 32768L ; 
  626.     else {
  627.         
  628.       if ( stringptr == 256 ) 
  629.       rewrite ( pool , poolfilename ) ; 
  630.       equiv [ p ] = stringptr + 32768L ; 
  631.       l = l - doublechars - 1 ; 
  632.       if ( l > 99 ) 
  633.       {
  634.         putc ('\n',  stdout );
  635.         Fputs( stdout ,  "! Preprocessed string is too long" ) ; 
  636.         error () ; 
  637.       } 
  638.       stringptr = stringptr + 1 ; 
  639.       fprintf( pool , "%c%c",  xchr [ 48 + l / 10 ] , xchr [ 48 + l % 10 ] ) ; 
  640.       poolchecksum = poolchecksum + poolchecksum + l ; 
  641.       while ( poolchecksum > 536870839L ) poolchecksum = poolchecksum - 
  642.       536870839L ; 
  643.       i = idfirst + 1 ; 
  644.       while ( i < idloc ) {
  645.           
  646.         putc ( xchr [ buffer [ i ] ] ,  pool );
  647.         poolchecksum = poolchecksum + poolchecksum + buffer [ i ] ; 
  648.         while ( poolchecksum > 536870839L ) poolchecksum = poolchecksum - 
  649.         536870839L ; 
  650.         if ( ( buffer [ i ] == 34 ) || ( buffer [ i ] == 64 ) ) 
  651.         i = i + 2 ; 
  652.         else i = i + 1 ; 
  653.       } 
  654.       putc ('\n',  pool );
  655.     } 
  656.       } 
  657.     } 
  658.   } 
  659.   Result = p ; 
  660.   return(Result) ; 
  661. } 
  662. namepointer zmodlookup ( l ) 
  663. sixteenbits l ; 
  664. {/* 31 */ register namepointer Result; char c  ; 
  665.   integer j  ; 
  666.   integer k  ; 
  667.   char w  ; 
  668.   namepointer p  ; 
  669.   namepointer q  ; 
  670.   c = 2 ; 
  671.   q = 0 ; 
  672.   p = ilk [ 0 ] ; 
  673.   while ( p != 0 ) {
  674.       
  675.     {
  676.       k = bytestart [ p ] ; 
  677.       w = p % 3 ; 
  678.       c = 1 ; 
  679.       j = 1 ; 
  680.       while ( ( k < bytestart [ p + 3 ] ) && ( j <= l ) && ( modtext [ j ] == 
  681.       bytemem [ w ][ k ] ) ) {
  682.       
  683.     k = k + 1 ; 
  684.     j = j + 1 ; 
  685.       } 
  686.       if ( k == bytestart [ p + 3 ] ) 
  687.       if ( j > l ) 
  688.       c = 1 ; 
  689.       else c = 4 ; 
  690.       else if ( j > l ) 
  691.       c = 3 ; 
  692.       else if ( modtext [ j ] < bytemem [ w ][ k ] ) 
  693.       c = 0 ; 
  694.       else c = 2 ; 
  695.     } 
  696.     q = p ; 
  697.     if ( c == 0 ) 
  698.     p = link [ q ] ; 
  699.     else if ( c == 2 ) 
  700.     p = ilk [ q ] ; 
  701.     else goto lab31 ; 
  702.   } 
  703.   w = nameptr % 3 ; 
  704.   k = byteptr [ w ] ; 
  705.   if ( k + l > maxbytes ) 
  706.   {
  707.     putc ('\n',  stdout );
  708.     fprintf( stdout , "%s%s%s",  "! Sorry, " , "byte memory" , " capacity exceeded" ) ; 
  709.     error () ; 
  710.     history = 3 ; 
  711.     uexit ( 1 ) ; 
  712.   } 
  713.   if ( nameptr > maxnames - 3 ) 
  714.   {
  715.     putc ('\n',  stdout );
  716.     fprintf( stdout , "%s%s%s",  "! Sorry, " , "name" , " capacity exceeded" ) ; 
  717.     error () ; 
  718.     history = 3 ; 
  719.     uexit ( 1 ) ; 
  720.   } 
  721.   p = nameptr ; 
  722.   if ( c == 0 ) 
  723.   link [ q ] = p ; 
  724.   else ilk [ q ] = p ; 
  725.   link [ p ] = 0 ; 
  726.   ilk [ p ] = 0 ; 
  727.   c = 1 ; 
  728.   equiv [ p ] = 0 ; 
  729.   {register integer for_end; j = 1 ; for_end = l ; if ( j <= for_end) do 
  730.     bytemem [ w ][ k + j - 1 ] = modtext [ j ] ; 
  731.   while ( j++ < for_end ) ; } 
  732.   byteptr [ w ] = k + l ; 
  733.   bytestart [ nameptr + 3 ] = k + l ; 
  734.   nameptr = nameptr + 1 ; 
  735.   lab31: if ( c != 1 ) 
  736.   {
  737.     {
  738.       putc ('\n',  stdout );
  739.       Fputs( stdout ,  "! Incompatible section names" ) ; 
  740.       error () ; 
  741.     } 
  742.     p = 0 ; 
  743.   } 
  744.   Result = p ; 
  745.   return(Result) ; 
  746. } 
  747. namepointer zprefixlookup ( l ) 
  748. sixteenbits l ; 
  749. {register namepointer Result; char c  ; 
  750.   integer count  ; 
  751.   integer j  ; 
  752.   integer k  ; 
  753.   char w  ; 
  754.   namepointer p  ; 
  755.   namepointer q  ; 
  756.   namepointer r  ; 
  757.   q = 0 ; 
  758.   p = ilk [ 0 ] ; 
  759.   count = 0 ; 
  760.   r = 0 ; 
  761.   while ( p != 0 ) {
  762.       
  763.     {
  764.       k = bytestart [ p ] ; 
  765.       w = p % 3 ; 
  766.       c = 1 ; 
  767.       j = 1 ; 
  768.       while ( ( k < bytestart [ p + 3 ] ) && ( j <= l ) && ( modtext [ j ] == 
  769.       bytemem [ w ][ k ] ) ) {
  770.       
  771.     k = k + 1 ; 
  772.     j = j + 1 ; 
  773.       } 
  774.       if ( k == bytestart [ p + 3 ] ) 
  775.       if ( j > l ) 
  776.       c = 1 ; 
  777.       else c = 4 ; 
  778.       else if ( j > l ) 
  779.       c = 3 ; 
  780.       else if ( modtext [ j ] < bytemem [ w ][ k ] ) 
  781.       c = 0 ; 
  782.       else c = 2 ; 
  783.     } 
  784.     if ( c == 0 ) 
  785.     p = link [ p ] ; 
  786.     else if ( c == 2 ) 
  787.     p = ilk [ p ] ; 
  788.     else {
  789.     
  790.       r = p ; 
  791.       count = count + 1 ; 
  792.       q = ilk [ p ] ; 
  793.       p = link [ p ] ; 
  794.     } 
  795.     if ( p == 0 ) 
  796.     {
  797.       p = q ; 
  798.       q = 0 ; 
  799.     } 
  800.   } 
  801.   if ( count != 1 ) 
  802.   if ( count == 0 ) 
  803.   {
  804.     putc ('\n',  stdout );
  805.     Fputs( stdout ,  "! Name does not match" ) ; 
  806.     error () ; 
  807.   } 
  808.   else {
  809.       
  810.     putc ('\n',  stdout );
  811.     Fputs( stdout ,  "! Ambiguous prefix" ) ; 
  812.     error () ; 
  813.   } 
  814.   Result = r ; 
  815.   return(Result) ; 
  816. } 
  817. void zstoretwobytes ( x ) 
  818. sixteenbits x ; 
  819. {if ( tokptr [ z ] + 2 > maxtoks ) 
  820.   {
  821.     putc ('\n',  stdout );
  822.     fprintf( stdout , "%s%s%s",  "! Sorry, " , "token" , " capacity exceeded" ) ; 
  823.     error () ; 
  824.     history = 3 ; 
  825.     uexit ( 1 ) ; 
  826.   } 
  827.   tokmem [ z ][ tokptr [ z ] ] = x / 256 ; 
  828.   tokmem [ z ][ tokptr [ z ] + 1 ] = x % 256 ; 
  829.   tokptr [ z ] = tokptr [ z ] + 2 ; 
  830. } 
  831. void zpushlevel ( p ) 
  832. namepointer p ; 
  833. {if ( stackptr == stacksize ) 
  834.   {
  835.     putc ('\n',  stdout );
  836.     fprintf( stdout , "%s%s%s",  "! Sorry, " , "stack" , " capacity exceeded" ) ; 
  837.     error () ; 
  838.     history = 3 ; 
  839.     uexit ( 1 ) ; 
  840.   } 
  841.   else {
  842.       
  843.     stack [ stackptr ] = curstate ; 
  844.     stackptr = stackptr + 1 ; 
  845.     curstate .namefield = p ; 
  846.     curstate .replfield = equiv [ p ] ; 
  847.     zo = curstate .replfield % 4 ; 
  848.     curstate .bytefield = tokstart [ curstate .replfield ] ; 
  849.     curstate .endfield = tokstart [ curstate .replfield + 4 ] ; 
  850.     curstate .modfield = 0 ; 
  851.   } 
  852. } 
  853. void poplevel ( ) 
  854. {/* 10 */ if ( textlink [ curstate .replfield ] == 0 ) 
  855.   {
  856.     if ( ilk [ curstate .namefield ] == 3 ) 
  857.     {
  858.       nameptr = nameptr - 1 ; 
  859.       textptr = textptr - 1 ; 
  860.       z = textptr % 4 ; 
  861.       tokptr [ z ] = tokstart [ textptr ] ; 
  862.     } 
  863.   } 
  864.   else if ( textlink [ curstate .replfield ] < maxtexts ) 
  865.   {
  866.     curstate .replfield = textlink [ curstate .replfield ] ; 
  867.     zo = curstate .replfield % 4 ; 
  868.     curstate .bytefield = tokstart [ curstate .replfield ] ; 
  869.     curstate .endfield = tokstart [ curstate .replfield + 4 ] ; 
  870.     goto lab10 ; 
  871.   } 
  872.   stackptr = stackptr - 1 ; 
  873.   if ( stackptr > 0 ) 
  874.   {
  875.     curstate = stack [ stackptr ] ; 
  876.     zo = curstate .replfield % 4 ; 
  877.   } 
  878.   lab10: ; 
  879. } 
  880. sixteenbits getoutput ( ) 
  881. {/* 20 30 31 */ register sixteenbits Result; sixteenbits a  ; 
  882.   eightbits b  ; 
  883.   sixteenbits bal  ; 
  884.   integer k  ; 
  885.   char w  ; 
  886.   lab20: if ( stackptr == 0 ) 
  887.   {
  888.     a = 0 ; 
  889.     goto lab31 ; 
  890.   } 
  891.   if ( curstate .bytefield == curstate .endfield ) 
  892.   {
  893.     curval = - (integer) curstate .modfield ; 
  894.     poplevel () ; 
  895.     if ( curval == 0 ) 
  896.     goto lab20 ; 
  897.     a = 129 ; 
  898.     goto lab31 ; 
  899.   } 
  900.   a = tokmem [ zo ][ curstate .bytefield ] ; 
  901.   curstate .bytefield = curstate .bytefield + 1 ; 
  902.   if ( a < 128 ) 
  903.   if ( a == 0 ) 
  904.   {
  905.     pushlevel ( nameptr - 1 ) ; 
  906.     goto lab20 ; 
  907.   } 
  908.   else goto lab31 ; 
  909.   a = ( a - 128 ) * 256 + tokmem [ zo ][ curstate .bytefield ] ; 
  910.   curstate .bytefield = curstate .bytefield + 1 ; 
  911.   if ( a < 10240 ) 
  912.   {
  913.     switch ( ilk [ a ] ) 
  914.     {case 0 : 
  915.       {
  916.     curval = a ; 
  917.     a = 130 ; 
  918.       } 
  919.       break ; 
  920.     case 1 : 
  921.       {
  922.     curval = equiv [ a ] - 32768L ; 
  923.     a = 128 ; 
  924.       } 
  925.       break ; 
  926.     case 2 : 
  927.       {
  928.     pushlevel ( a ) ; 
  929.     goto lab20 ; 
  930.       } 
  931.       break ; 
  932.     case 3 : 
  933.       {
  934.     while ( ( curstate .bytefield == curstate .endfield ) && ( stackptr > 
  935.     0 ) ) poplevel () ; 
  936.     if ( ( stackptr == 0 ) || ( tokmem [ zo ][ curstate .bytefield ] != 40 
  937.     ) ) 
  938.     {
  939.       {
  940.         putc ('\n',  stdout );
  941.         Fputs( stdout ,  "! No parameter given for " ) ; 
  942.       } 
  943.       printid ( a ) ; 
  944.       error () ; 
  945.       goto lab20 ; 
  946.     } 
  947.     bal = 1 ; 
  948.     curstate .bytefield = curstate .bytefield + 1 ; 
  949.     while ( true ) {
  950.         
  951.       b = tokmem [ zo ][ curstate .bytefield ] ; 
  952.       curstate .bytefield = curstate .bytefield + 1 ; 
  953.       if ( b == 0 ) 
  954.       storetwobytes ( nameptr + 32767 ) ; 
  955.       else {
  956.           
  957.         if ( b >= 128 ) 
  958.         {
  959.           {
  960.         if ( tokptr [ z ] == maxtoks ) 
  961.         {
  962.           putc ('\n',  stdout );
  963.           fprintf( stdout , "%s%s%s",  "! Sorry, " , "token" ,                   " capacity exceeded" ) ; 
  964.           error () ; 
  965.           history = 3 ; 
  966.           uexit ( 1 ) ; 
  967.         } 
  968.         tokmem [ z ][ tokptr [ z ] ] = b ; 
  969.         tokptr [ z ] = tokptr [ z ] + 1 ; 
  970.           } 
  971.           b = tokmem [ zo ][ curstate .bytefield ] ; 
  972.           curstate .bytefield = curstate .bytefield + 1 ; 
  973.         } 
  974.         else switch ( b ) 
  975.         {case 40 : 
  976.           bal = bal + 1 ; 
  977.           break ; 
  978.         case 41 : 
  979.           {
  980.         bal = bal - 1 ; 
  981.         if ( bal == 0 ) 
  982.         goto lab30 ; 
  983.           } 
  984.           break ; 
  985.         case 39 : 
  986.           do {
  987.           { 
  988.           if ( tokptr [ z ] == maxtoks ) 
  989.           {
  990.             putc ('\n',  stdout );
  991.             fprintf( stdout , "%s%s%s",  "! Sorry, " , "token" ,                     " capacity exceeded" ) ; 
  992.             error () ; 
  993.             history = 3 ; 
  994.             uexit ( 1 ) ; 
  995.           } 
  996.           tokmem [ z ][ tokptr [ z ] ] = b ; 
  997.           tokptr [ z ] = tokptr [ z ] + 1 ; 
  998.         } 
  999.         b = tokmem [ zo ][ curstate .bytefield ] ; 
  1000.         curstate .bytefield = curstate .bytefield + 1 ; 
  1001.           } while ( ! ( b == 39 ) ) ; 
  1002.           break ; 
  1003.           default: 
  1004.           ; 
  1005.           break ; 
  1006.         } 
  1007.         {
  1008.           if ( tokptr [ z ] == maxtoks ) 
  1009.           {
  1010.         putc ('\n',  stdout );
  1011.         fprintf( stdout , "%s%s%s",  "! Sorry, " , "token" , " capacity exceeded"                 ) ; 
  1012.         error () ; 
  1013.         history = 3 ; 
  1014.         uexit ( 1 ) ; 
  1015.           } 
  1016.           tokmem [ z ][ tokptr [ z ] ] = b ; 
  1017.           tokptr [ z ] = tokptr [ z ] + 1 ; 
  1018.         } 
  1019.       } 
  1020.     } 
  1021.     lab30: ; 
  1022.     equiv [ nameptr ] = textptr ; 
  1023.     ilk [ nameptr ] = 2 ; 
  1024.     w = nameptr % 3 ; 
  1025.     k = byteptr [ w ] ; 
  1026.     if ( nameptr > maxnames - 3 ) 
  1027.     {
  1028.       putc ('\n',  stdout );
  1029.       fprintf( stdout , "%s%s%s",  "! Sorry, " , "name" , " capacity exceeded" ) ; 
  1030.       error () ; 
  1031.       history = 3 ; 
  1032.       uexit ( 1 ) ; 
  1033.     } 
  1034.     bytestart [ nameptr + 3 ] = k ; 
  1035.     nameptr = nameptr + 1 ; 
  1036.     if ( textptr > maxtexts - 4 ) 
  1037.     {
  1038.       putc ('\n',  stdout );
  1039.       fprintf( stdout , "%s%s%s",  "! Sorry, " , "text" , " capacity exceeded" ) ; 
  1040.       error () ; 
  1041.       history = 3 ; 
  1042.       uexit ( 1 ) ; 
  1043.     } 
  1044.     textlink [ textptr ] = 0 ; 
  1045.     tokstart [ textptr + 4 ] = tokptr [ z ] ; 
  1046.     textptr = textptr + 1 ; 
  1047.     z = textptr % 4 ; 
  1048.     pushlevel ( a ) ; 
  1049.     goto lab20 ; 
  1050.       } 
  1051.       break ; 
  1052.       default: 
  1053.       {
  1054.     putc ('\n',  stdout );
  1055.     fprintf( stdout , "%s%s%c",  "! This can't happen (" , "output" , ')' ) ; 
  1056.     error () ; 
  1057.     history = 3 ; 
  1058.     uexit ( 1 ) ; 
  1059.       } 
  1060.       break ; 
  1061.     } 
  1062.     goto lab31 ; 
  1063.   } 
  1064.   if ( a < 20480 ) 
  1065.   {
  1066.     a = a - 10240 ; 
  1067.     if ( equiv [ a ] != 0 ) 
  1068.     pushlevel ( a ) ; 
  1069.     else if ( a != 0 ) 
  1070.     {
  1071.       {
  1072.     putc ('\n',  stdout );
  1073.     Fputs( stdout ,  "! Not present: <" ) ; 
  1074.       } 
  1075.       printid ( a ) ; 
  1076.       putc ( '>' ,  stdout );
  1077.       error () ; 
  1078.     } 
  1079.     goto lab20 ; 
  1080.   } 
  1081.   curval = a - 20480 ; 
  1082.   a = 129 ; 
  1083.   curstate .modfield = curval ; 
  1084.   lab31: Result = a ; 
  1085.   return(Result) ; 
  1086. } 
  1087. void flushbuffer ( ) 
  1088. {integer k  ; 
  1089.   integer b  ; 
  1090.   b = breakptr ; 
  1091.   if ( ( semiptr != 0 ) && ( outptr - semiptr <= linelength ) ) 
  1092.   breakptr = semiptr ; 
  1093.   {register integer for_end; k = 1 ; for_end = breakptr ; if ( k <= for_end) 
  1094.   do 
  1095.     putc ( xchr [ outbuf [ k - 1 ] ] ,  Pascalfile );
  1096.   while ( k++ < for_end ) ; } 
  1097.   putc ('\n',  Pascalfile );
  1098.   line = line + 1 ; 
  1099.   if ( line % 100 == 0 ) 
  1100.   {
  1101.     putc ( '.' ,  stdout );
  1102.     if ( line % 500 == 0 ) 
  1103.     fprintf( stdout , "%ld",  (long)line ) ; 
  1104.     flush ( stdout ) ; 
  1105.   } 
  1106.   if ( breakptr < outptr ) 
  1107.   {
  1108.     if ( outbuf [ breakptr ] == 32 ) 
  1109.     {
  1110.       breakptr = breakptr + 1 ; 
  1111.       if ( breakptr > b ) 
  1112.       b = breakptr ; 
  1113.     } 
  1114.     {register integer for_end; k = breakptr ; for_end = outptr - 1 ; if ( k 
  1115.     <= for_end) do 
  1116.       outbuf [ k - breakptr ] = outbuf [ k ] ; 
  1117.     while ( k++ < for_end ) ; } 
  1118.   } 
  1119.   outptr = outptr - breakptr ; 
  1120.   breakptr = b - breakptr ; 
  1121.   semiptr = 0 ; 
  1122.   if ( outptr > linelength ) 
  1123.   {
  1124.     {
  1125.       putc ('\n',  stdout );
  1126.       Fputs( stdout ,  "! Long line must be truncated" ) ; 
  1127.       error () ; 
  1128.     } 
  1129.     outptr = linelength ; 
  1130.   } 
  1131. } 
  1132. void zappval ( v ) 
  1133. integer v ; 
  1134. {integer k  ; 
  1135.   k = outbufsize ; 
  1136.   do {
  1137.       outbuf [ k ] = v % 10 ; 
  1138.     v = v / 10 ; 
  1139.     k = k - 1 ; 
  1140.   } while ( ! ( v == 0 ) ) ; 
  1141.   do {
  1142.       k = k + 1 ; 
  1143.     {
  1144.       outbuf [ outptr ] = outbuf [ k ] + 48 ; 
  1145.       outptr = outptr + 1 ; 
  1146.     } 
  1147.   } while ( ! ( k == outbufsize ) ) ; 
  1148. } 
  1149. void zsendout ( t , v ) 
  1150. eightbits t ; 
  1151. sixteenbits v ; 
  1152. {/* 20 */ integer k  ; 
  1153.   lab20: switch ( outstate ) 
  1154.   {case 1 : 
  1155.     if ( t != 3 ) 
  1156.     {
  1157.       breakptr = outptr ; 
  1158.       if ( t == 2 ) 
  1159.       {
  1160.     outbuf [ outptr ] = 32 ; 
  1161.     outptr = outptr + 1 ; 
  1162.       } 
  1163.     } 
  1164.     break ; 
  1165.   case 2 : 
  1166.     {
  1167.       {
  1168.     outbuf [ outptr ] = 44 - outapp ; 
  1169.     outptr = outptr + 1 ; 
  1170.       } 
  1171.       if ( outptr > linelength ) 
  1172.       flushbuffer () ; 
  1173.       breakptr = outptr ; 
  1174.     } 
  1175.     break ; 
  1176.   case 3 : 
  1177.   case 4 : 
  1178.     {
  1179.       if ( ( outval < 0 ) || ( ( outval == 0 ) && ( lastsign < 0 ) ) ) 
  1180.       {
  1181.     outbuf [ outptr ] = 45 ; 
  1182.     outptr = outptr + 1 ; 
  1183.       } 
  1184.       else if ( outsign > 0 ) 
  1185.       {
  1186.     outbuf [ outptr ] = outsign ; 
  1187.     outptr = outptr + 1 ; 
  1188.       } 
  1189.       appval ( abs ( outval ) ) ; 
  1190.       if ( outptr > linelength ) 
  1191.       flushbuffer () ; 
  1192.       outstate = outstate - 2 ; 
  1193.       goto lab20 ; 
  1194.     } 
  1195.     break ; 
  1196.   case 5 : 
  1197.     {
  1198.       if ( ( t == 3 ) || ( ( ( t == 2 ) && ( v == 3 ) && ( ( ( outcontrib [ 1 
  1199.       ] == 68 ) && ( outcontrib [ 2 ] == 73 ) && ( outcontrib [ 3 ] == 86 ) ) 
  1200.       || ( ( outcontrib [ 1 ] == 100 ) && ( outcontrib [ 2 ] == 105 ) && ( 
  1201.       outcontrib [ 3 ] == 118 ) ) || ( ( outcontrib [ 1 ] == 77 ) && ( 
  1202.       outcontrib [ 2 ] == 79 ) && ( outcontrib [ 3 ] == 68 ) ) || ( ( 
  1203.       outcontrib [ 1 ] == 109 ) && ( outcontrib [ 2 ] == 111 ) && ( outcontrib 
  1204.       [ 3 ] == 100 ) ) ) ) || ( ( t == 0 ) && ( ( v == 42 ) || ( v == 47 ) ) ) 
  1205.       ) ) 
  1206.       {
  1207.     if ( ( outval < 0 ) || ( ( outval == 0 ) && ( lastsign < 0 ) ) ) 
  1208.     {
  1209.       outbuf [ outptr ] = 45 ; 
  1210.       outptr = outptr + 1 ; 
  1211.     } 
  1212.     else if ( outsign > 0 ) 
  1213.     {
  1214.       outbuf [ outptr ] = outsign ; 
  1215.       outptr = outptr + 1 ; 
  1216.     } 
  1217.     appval ( abs ( outval ) ) ; 
  1218.     if ( outptr > linelength ) 
  1219.     flushbuffer () ; 
  1220.     outsign = 43 ; 
  1221.     outval = outapp ; 
  1222.       } 
  1223.       else outval = outval + outapp ; 
  1224.       outstate = 3 ; 
  1225.       goto lab20 ; 
  1226.     } 
  1227.     break ; 
  1228.   case 0 : 
  1229.     if ( t != 3 ) 
  1230.     breakptr = outptr ; 
  1231.     break ; 
  1232.     default: 
  1233.     ; 
  1234.     break ; 
  1235.   } 
  1236.   if ( t != 0 ) 
  1237.   {register integer for_end; k = 1 ; for_end = v ; if ( k <= for_end) do 
  1238.     {
  1239.       outbuf [ outptr ] = outcontrib [ k ] ; 
  1240.       outptr = outptr + 1 ; 
  1241.     } 
  1242.   while ( k++ < for_end ) ; } 
  1243.   else {
  1244.       
  1245.     outbuf [ outptr ] = v ; 
  1246.     outptr = outptr + 1 ; 
  1247.   } 
  1248.   if ( outptr > linelength ) 
  1249.   flushbuffer () ; 
  1250.   if ( ( t == 0 ) && ( ( v == 59 ) || ( v == 125 ) ) ) 
  1251.   {
  1252.     semiptr = outptr ; 
  1253.     breakptr = outptr ; 
  1254.   } 
  1255.   if ( t >= 2 ) 
  1256.   outstate = 1 ; 
  1257.   else outstate = 0 ; 
  1258. } 
  1259. void zsendsign ( v ) 
  1260. integer v ; 
  1261. {switch ( outstate ) 
  1262.   {case 2 : 
  1263.   case 4 : 
  1264.     outapp = outapp * v ; 
  1265.     break ; 
  1266.   case 3 : 
  1267.     {
  1268.       outapp = v ; 
  1269.       outstate = 4 ; 
  1270.     } 
  1271.     break ; 
  1272.   case 5 : 
  1273.     {
  1274.       outval = outval + outapp ; 
  1275.       outapp = v ; 
  1276.       outstate = 4 ; 
  1277.     } 
  1278.     break ; 
  1279.     default: 
  1280.     {
  1281.       breakptr = outptr ; 
  1282.       outapp = v ; 
  1283.       outstate = 2 ; 
  1284.     } 
  1285.     break ; 
  1286.   } 
  1287.   lastsign = outapp ; 
  1288. } 
  1289. void zsendval ( v ) 
  1290. integer v ; 
  1291. {/* 666 10 */ switch ( outstate ) 
  1292.   {case 1 : 
  1293.     {
  1294.       if ( ( outptr == breakptr + 3 ) || ( ( outptr == breakptr + 4 ) && ( 
  1295.       outbuf [ breakptr ] == 32 ) ) ) 
  1296.       if ( ( ( outbuf [ outptr - 3 ] == 68 ) && ( outbuf [ outptr - 2 ] == 73 
  1297.       ) && ( outbuf [ outptr - 1 ] == 86 ) ) || ( ( outbuf [ outptr - 3 ] == 
  1298.       100 ) && ( outbuf [ outptr - 2 ] == 105 ) && ( outbuf [ outptr - 1 ] == 
  1299.       118 ) ) || ( ( outbuf [ outptr - 3 ] == 77 ) && ( outbuf [ outptr - 2 ] 
  1300.       == 79 ) && ( outbuf [ outptr - 1 ] == 68 ) ) || ( ( outbuf [ outptr - 3 
  1301.       ] == 109 ) && ( outbuf [ outptr - 2 ] == 111 ) && ( outbuf [ outptr - 1 
  1302.       ] == 100 ) ) ) 
  1303.       goto lab666 ; 
  1304.       outsign = 32 ; 
  1305.       outstate = 3 ; 
  1306.       outval = v ; 
  1307.       breakptr = outptr ; 
  1308.       lastsign = 1 ; 
  1309.     } 
  1310.     break ; 
  1311.   case 0 : 
  1312.     {
  1313.       if ( ( outptr == breakptr + 1 ) && ( ( outbuf [ breakptr ] == 42 ) || ( 
  1314.       outbuf [ breakptr ] == 47 ) ) ) 
  1315.       goto lab666 ; 
  1316.       outsign = 0 ; 
  1317.       outstate = 3 ; 
  1318.       outval = v ; 
  1319.       breakptr = outptr ; 
  1320.       lastsign = 1 ; 
  1321.     } 
  1322.     break ; 
  1323.   case 2 : 
  1324.     {
  1325.       outsign = 43 ; 
  1326.       outstate = 3 ; 
  1327.       outval = outapp * v ; 
  1328.     } 
  1329.     break ; 
  1330.   case 3 : 
  1331.     {
  1332.       outstate = 5 ; 
  1333.       outapp = v ; 
  1334.       {
  1335.     putc ('\n',  stdout );
  1336.     Fputs( stdout ,  "! Two numbers occurred without a sign between them"         ) ; 
  1337.     error () ; 
  1338.       } 
  1339.     } 
  1340.     break ; 
  1341.   case 4 : 
  1342.     {
  1343.       outstate = 5 ; 
  1344.       outapp = outapp * v ; 
  1345.     } 
  1346.     break ; 
  1347.   case 5 : 
  1348.     {
  1349.       outval = outval + outapp ; 
  1350.       outapp = v ; 
  1351.       {
  1352.     putc ('\n',  stdout );
  1353.     Fputs( stdout ,  "! Two numbers occurred without a sign between them"         ) ; 
  1354.     error () ; 
  1355.       } 
  1356.     } 
  1357.     break ; 
  1358.     default: 
  1359.     goto lab666 ; 
  1360.     break ; 
  1361.   } 
  1362.   goto lab10 ; 
  1363.   lab666: if ( v >= 0 ) 
  1364.   {
  1365.     if ( outstate == 1 ) 
  1366.     {
  1367.       breakptr = outptr ; 
  1368.       {
  1369.     outbuf [ outptr ] = 32 ; 
  1370.     outptr = outptr + 1 ; 
  1371.       } 
  1372.     } 
  1373.     appval ( v ) ; 
  1374.     if ( outptr > linelength ) 
  1375.     flushbuffer () ; 
  1376.     outstate = 1 ; 
  1377.   } 
  1378.   else {
  1379.       
  1380.     {
  1381.       outbuf [ outptr ] = 40 ; 
  1382.       outptr = outptr + 1 ; 
  1383.     } 
  1384.     {
  1385.       outbuf [ outptr ] = 45 ; 
  1386.       outptr = outptr + 1 ; 
  1387.     } 
  1388.     appval ( - (integer) v ) ; 
  1389.     {
  1390.       outbuf [ outptr ] = 41 ; 
  1391.       outptr = outptr + 1 ; 
  1392.     } 
  1393.     if ( outptr > linelength ) 
  1394.     flushbuffer () ; 
  1395.     outstate = 0 ; 
  1396.   } 
  1397.   lab10: ; 
  1398. } 
  1399. void sendtheoutput ( ) 
  1400. {/* 2 21 22 */ eightbits curchar  ; 
  1401.   integer k  ; 
  1402.   integer j  ; 
  1403.   char w  ; 
  1404.   integer n  ; 
  1405.   while ( stackptr > 0 ) {
  1406.       
  1407.     curchar = getoutput () ; 
  1408.     lab21: switch ( curchar ) 
  1409.     {case 0 : 
  1410.       ; 
  1411.       break ; 
  1412.     case 65 : 
  1413.     case 66 : 
  1414.     case 67 : 
  1415.     case 68 : 
  1416.     case 69 : 
  1417.     case 70 : 
  1418.     case 71 : 
  1419.     case 72 : 
  1420.     case 73 : 
  1421.     case 74 : 
  1422.     case 75 : 
  1423.     case 76 : 
  1424.     case 77 : 
  1425.     case 78 : 
  1426.     case 79 : 
  1427.     case 80 : 
  1428.     case 81 : 
  1429.     case 82 : 
  1430.     case 83 : 
  1431.     case 84 : 
  1432.     case 85 : 
  1433.     case 86 : 
  1434.     case 87 : 
  1435.     case 88 : 
  1436.     case 89 : 
  1437.     case 90 : 
  1438.     case 97 : 
  1439.     case 98 : 
  1440.     case 99 : 
  1441.     case 100 : 
  1442.     case 101 : 
  1443.     case 102 : 
  1444.     case 103 : 
  1445.     case 104 : 
  1446.     case 105 : 
  1447.     case 106 : 
  1448.     case 107 : 
  1449.     case 108 : 
  1450.     case 109 : 
  1451.     case 110 : 
  1452.     case 111 : 
  1453.     case 112 : 
  1454.     case 113 : 
  1455.     case 114 : 
  1456.     case 115 : 
  1457.     case 116 : 
  1458.     case 117 : 
  1459.     case 118 : 
  1460.     case 119 : 
  1461.     case 120 : 
  1462.     case 121 : 
  1463.     case 122 : 
  1464.       {
  1465.     outcontrib [ 1 ] = curchar ; 
  1466.     sendout ( 2 , 1 ) ; 
  1467.       } 
  1468.       break ; 
  1469.     case 130 : 
  1470.       {
  1471.     k = 0 ; 
  1472.     j = bytestart [ curval ] ; 
  1473.     w = curval % 3 ; 
  1474.     while ( ( k < maxidlength ) && ( j < bytestart [ curval + 3 ] ) ) {
  1475.         
  1476.       k = k + 1 ; 
  1477.       outcontrib [ k ] = bytemem [ w ][ j ] ; 
  1478.       j = j + 1 ; 
  1479.       if ( outcontrib [ k ] == 95 ) 
  1480.       k = k - 1 ; 
  1481.     } 
  1482.     sendout ( 2 , k ) ; 
  1483.       } 
  1484.       break ; 
  1485.     case 48 : 
  1486.     case 49 : 
  1487.     case 50 : 
  1488.     case 51 : 
  1489.     case 52 : 
  1490.     case 53 : 
  1491.     case 54 : 
  1492.     case 55 : 
  1493.     case 56 : 
  1494.     case 57 : 
  1495.       {
  1496.     n = 0 ; 
  1497.     do {
  1498.         curchar = curchar - 48 ; 
  1499.       if ( n >= 214748364L ) 
  1500.       {
  1501.         putc ('\n',  stdout );
  1502.         Fputs( stdout ,  "! Constant too big" ) ; 
  1503.         error () ; 
  1504.       } 
  1505.       else n = 10 * n + curchar ; 
  1506.       curchar = getoutput () ; 
  1507.     } while ( ! ( ( curchar > 57 ) || ( curchar < 48 ) ) ) ; 
  1508.     sendval ( n ) ; 
  1509.     k = 0 ; 
  1510.     if ( curchar == 101 ) 
  1511.     curchar = 69 ; 
  1512.     if ( curchar == 69 ) 
  1513.     goto lab2 ; 
  1514.     else goto lab21 ; 
  1515.       } 
  1516.       break ; 
  1517.     case 125 : 
  1518.       sendval ( poolchecksum ) ; 
  1519.       break ; 
  1520.     case 12 : 
  1521.       {
  1522.     n = 0 ; 
  1523.     curchar = 48 ; 
  1524.     do {
  1525.         curchar = curchar - 48 ; 
  1526.       if ( n >= 268435456L ) 
  1527.       {
  1528.         putc ('\n',  stdout );
  1529.         Fputs( stdout ,  "! Constant too big" ) ; 
  1530.         error () ; 
  1531.       } 
  1532.       else n = 8 * n + curchar ; 
  1533.       curchar = getoutput () ; 
  1534.     } while ( ! ( ( curchar > 55 ) || ( curchar < 48 ) ) ) ; 
  1535.     sendval ( n ) ; 
  1536.     goto lab21 ; 
  1537.       } 
  1538.       break ; 
  1539.     case 13 : 
  1540.       {
  1541.     n = 0 ; 
  1542.     curchar = 48 ; 
  1543.     do {
  1544.         if ( curchar >= 65 ) 
  1545.       curchar = curchar - 55 ; 
  1546.       else curchar = curchar - 48 ; 
  1547.       if ( n >= 134217728L ) 
  1548.       {
  1549.         putc ('\n',  stdout );
  1550.         Fputs( stdout ,  "! Constant too big" ) ; 
  1551.         error () ; 
  1552.       } 
  1553.       else n = 16 * n + curchar ; 
  1554.       curchar = getoutput () ; 
  1555.     } while ( ! ( ( curchar > 70 ) || ( curchar < 48 ) || ( ( curchar > 57 
  1556.     ) && ( curchar < 65 ) ) ) ) ; 
  1557.     sendval ( n ) ; 
  1558.     goto lab21 ; 
  1559.       } 
  1560.       break ; 
  1561.     case 128 : 
  1562.       sendval ( curval ) ; 
  1563.       break ; 
  1564.     case 46 : 
  1565.       {
  1566.     k = 1 ; 
  1567.     outcontrib [ 1 ] = 46 ; 
  1568.     curchar = getoutput () ; 
  1569.     if ( curchar == 46 ) 
  1570.     {
  1571.       outcontrib [ 2 ] = 46 ; 
  1572.       sendout ( 1 , 2 ) ; 
  1573.     } 
  1574.     else if ( ( curchar >= 48 ) && ( curchar <= 57 ) ) 
  1575.     goto lab2 ; 
  1576.     else {
  1577.         
  1578.       sendout ( 0 , 46 ) ; 
  1579.       goto lab21 ; 
  1580.     } 
  1581.       } 
  1582.       break ; 
  1583.     case 43 : 
  1584.     case 45 : 
  1585.       sendsign ( 44 - curchar ) ; 
  1586.       break ; 
  1587.     case 4 : 
  1588.       {
  1589.     outcontrib [ 1 ] = 97 ; 
  1590.     outcontrib [ 2 ] = 110 ; 
  1591.     outcontrib [ 3 ] = 100 ; 
  1592.     sendout ( 2 , 3 ) ; 
  1593.       } 
  1594.       break ; 
  1595.     case 5 : 
  1596.       {
  1597.     outcontrib [ 1 ] = 110 ; 
  1598.     outcontrib [ 2 ] = 111 ; 
  1599.     outcontrib [ 3 ] = 116 ; 
  1600.     sendout ( 2 , 3 ) ; 
  1601.       } 
  1602.       break ; 
  1603.     case 6 : 
  1604.       {
  1605.     outcontrib [ 1 ] = 105 ; 
  1606.     outcontrib [ 2 ] = 110 ; 
  1607.     sendout ( 2 , 2 ) ; 
  1608.       } 
  1609.       break ; 
  1610.     case 31 : 
  1611.       {
  1612.     outcontrib [ 1 ] = 111 ; 
  1613.     outcontrib [ 2 ] = 114 ; 
  1614.     sendout ( 2 , 2 ) ; 
  1615.       } 
  1616.       break ; 
  1617.     case 24 : 
  1618.       {
  1619.     outcontrib [ 1 ] = 58 ; 
  1620.     outcontrib [ 2 ] = 61 ; 
  1621.     sendout ( 1 , 2 ) ; 
  1622.       } 
  1623.       break ; 
  1624.     case 26 : 
  1625.       {
  1626.     outcontrib [ 1 ] = 60 ; 
  1627.     outcontrib [ 2 ] = 62 ; 
  1628.     sendout ( 1 , 2 ) ; 
  1629.       } 
  1630.       break ; 
  1631.     case 28 : 
  1632.       {
  1633.     outcontrib [ 1 ] = 60 ; 
  1634.     outcontrib [ 2 ] = 61 ; 
  1635.     sendout ( 1 , 2 ) ; 
  1636.       } 
  1637.       break ; 
  1638.     case 29 : 
  1639.       {
  1640.     outcontrib [ 1 ] = 62 ; 
  1641.     outcontrib [ 2 ] = 61 ; 
  1642.     sendout ( 1 , 2 ) ; 
  1643.       } 
  1644.       break ; 
  1645.     case 30 : 
  1646.       {
  1647.     outcontrib [ 1 ] = 61 ; 
  1648.     outcontrib [ 2 ] = 61 ; 
  1649.     sendout ( 1 , 2 ) ; 
  1650.       } 
  1651.       break ; 
  1652.     case 32 : 
  1653.       {
  1654.     outcontrib [ 1 ] = 46 ; 
  1655.     outcontrib [ 2 ] = 46 ; 
  1656.     sendout ( 1 , 2 ) ; 
  1657.       } 
  1658.       break ; 
  1659.     case 39 : 
  1660.       {
  1661.     k = 1 ; 
  1662.     outcontrib [ 1 ] = 39 ; 
  1663.     do {
  1664.         if ( k < linelength ) 
  1665.       k = k + 1 ; 
  1666.       outcontrib [ k ] = getoutput () ; 
  1667.     } while ( ! ( ( outcontrib [ k ] == 39 ) || ( stackptr == 0 ) ) ) ; 
  1668.     if ( k == linelength ) 
  1669.     {
  1670.       putc ('\n',  stdout );
  1671.       Fputs( stdout ,  "! String too long" ) ; 
  1672.       error () ; 
  1673.     } 
  1674.     sendout ( 1 , k ) ; 
  1675.     curchar = getoutput () ; 
  1676.     if ( curchar == 39 ) 
  1677.     outstate = 6 ; 
  1678.     goto lab21 ; 
  1679.       } 
  1680.       break ; 
  1681.     case 33 : 
  1682.     case 34 : 
  1683.     case 35 : 
  1684.     case 36 : 
  1685.     case 37 : 
  1686.     case 38 : 
  1687.     case 40 : 
  1688.     case 41 : 
  1689.     case 42 : 
  1690.     case 44 : 
  1691.     case 47 : 
  1692.     case 58 : 
  1693.     case 59 : 
  1694.     case 60 : 
  1695.     case 61 : 
  1696.     case 62 : 
  1697.     case 63 : 
  1698.     case 64 : 
  1699.     case 91 : 
  1700.     case 92 : 
  1701.     case 93 : 
  1702.     case 94 : 
  1703.     case 95 : 
  1704.     case 96 : 
  1705.     case 123 : 
  1706.     case 124 : 
  1707.       sendout ( 0 , curchar ) ; 
  1708.       break ; 
  1709.     case 9 : 
  1710.       {
  1711.     if ( bracelevel == 0 ) 
  1712.     sendout ( 0 , 123 ) ; 
  1713.     else sendout ( 0 , 91 ) ; 
  1714.     bracelevel = bracelevel + 1 ; 
  1715.       } 
  1716.       break ; 
  1717.     case 10 : 
  1718.       if ( bracelevel > 0 ) 
  1719.       {
  1720.     bracelevel = bracelevel - 1 ; 
  1721.     if ( bracelevel == 0 ) 
  1722.     sendout ( 0 , 125 ) ; 
  1723.     else sendout ( 0 , 93 ) ; 
  1724.       } 
  1725.       else {
  1726.       
  1727.     putc ('\n',  stdout );
  1728.     Fputs( stdout ,  "! Extra @}" ) ; 
  1729.     error () ; 
  1730.       } 
  1731.       break ; 
  1732.     case 129 : 
  1733.       {
  1734.     if ( bracelevel == 0 ) 
  1735.     sendout ( 0 , 123 ) ; 
  1736.     else sendout ( 0 , 91 ) ; 
  1737.     if ( curval < 0 ) 
  1738.     {
  1739.       sendout ( 0 , 58 ) ; 
  1740.       sendval ( - (integer) curval ) ; 
  1741.     } 
  1742.     else {
  1743.         
  1744.       sendval ( curval ) ; 
  1745.       sendout ( 0 , 58 ) ; 
  1746.     } 
  1747.     if ( bracelevel == 0 ) 
  1748.     sendout ( 0 , 125 ) ; 
  1749.     else sendout ( 0 , 93 ) ; 
  1750.       } 
  1751.       break ; 
  1752.     case 127 : 
  1753.       {
  1754.     sendout ( 3 , 0 ) ; 
  1755.     outstate = 6 ; 
  1756.       } 
  1757.       break ; 
  1758.     case 2 : 
  1759.       {
  1760.     k = 0 ; 
  1761.     do {
  1762.         if ( k < linelength ) 
  1763.       k = k + 1 ; 
  1764.       outcontrib [ k ] = getoutput () ; 
  1765.     } while ( ! ( ( outcontrib [ k ] == 2 ) || ( stackptr == 0 ) ) ) ; 
  1766.     if ( k == linelength ) 
  1767.     {
  1768.       putc ('\n',  stdout );
  1769.       Fputs( stdout ,  "! Verbatim string too long" ) ; 
  1770.       error () ; 
  1771.     } 
  1772.     sendout ( 1 , k - 1 ) ; 
  1773.       } 
  1774.       break ; 
  1775.     case 3 : 
  1776.       {
  1777.     sendout ( 1 , 0 ) ; 
  1778.     while ( outptr > 0 ) {
  1779.         
  1780.       if ( outptr <= linelength ) 
  1781.       breakptr = outptr ; 
  1782.       flushbuffer () ; 
  1783.     } 
  1784.     outstate = 0 ; 
  1785.       } 
  1786.       break ; 
  1787.       default: 
  1788.       {
  1789.     putc ('\n',  stdout );
  1790.     fprintf( stdout , "%s%ld",  "! Can't output ASCII code " , (long)curchar ) ; 
  1791.     error () ; 
  1792.       } 
  1793.       break ; 
  1794.     } 
  1795.     goto lab22 ; 
  1796.     lab2: do {
  1797.     if ( k < linelength ) 
  1798.       k = k + 1 ; 
  1799.       outcontrib [ k ] = curchar ; 
  1800.       curchar = getoutput () ; 
  1801.       if ( ( outcontrib [ k ] == 69 ) && ( ( curchar == 43 ) || ( curchar == 
  1802.       45 ) ) ) 
  1803.       {
  1804.     if ( k < linelength ) 
  1805.     k = k + 1 ; 
  1806.     outcontrib [ k ] = curchar ; 
  1807.     curchar = getoutput () ; 
  1808.       } 
  1809.       else if ( curchar == 101 ) 
  1810.       curchar = 69 ; 
  1811.     } while ( ! ( ( curchar != 69 ) && ( ( curchar < 48 ) || ( curchar > 57 ) 
  1812.     ) ) ) ; 
  1813.     if ( k == linelength ) 
  1814.     {
  1815.       putc ('\n',  stdout );
  1816.       Fputs( stdout ,  "! Fraction too long" ) ; 
  1817.       error () ; 
  1818.     } 
  1819.     sendout ( 3 , k ) ; 
  1820.     goto lab21 ; 
  1821.     lab22: ; 
  1822.   } 
  1823. } 
  1824. boolean linesdontmatch ( ) 
  1825. {/* 10 */ register boolean Result; integer k  ; 
  1826.   Result = true ; 
  1827.   if ( changelimit != limit ) 
  1828.   goto lab10 ; 
  1829.   if ( limit > 0 ) 
  1830.   {register integer for_end; k = 0 ; for_end = limit - 1 ; if ( k <= for_end) 
  1831.   do 
  1832.     if ( changebuffer [ k ] != buffer [ k ] ) 
  1833.     goto lab10 ; 
  1834.   while ( k++ < for_end ) ; } 
  1835.   Result = false ; 
  1836.   lab10: ; 
  1837.   return(Result) ; 
  1838. } 
  1839. void primethechangebuffer ( ) 
  1840. {/* 22 30 10 */ integer k  ; 
  1841.   changelimit = 0 ; 
  1842.   while ( true ) {
  1843.       
  1844.     line = line + 1 ; 
  1845.     if ( ! inputln ( changefile ) ) 
  1846.     goto lab10 ; 
  1847.     if ( limit < 2 ) 
  1848.     goto lab22 ; 
  1849.     if ( buffer [ 0 ] != 64 ) 
  1850.     goto lab22 ; 
  1851.     if ( ( buffer [ 1 ] >= 88 ) && ( buffer [ 1 ] <= 90 ) ) 
  1852.     buffer [ 1 ] = buffer [ 1 ] + 32 ; 
  1853.     if ( buffer [ 1 ] == 120 ) 
  1854.     goto lab30 ; 
  1855.     if ( ( buffer [ 1 ] == 121 ) || ( buffer [ 1 ] == 122 ) ) 
  1856.     {
  1857.       loc = 2 ; 
  1858.       {
  1859.     putc ('\n',  stdout );
  1860.     Fputs( stdout ,  "! Where is the matching @x?" ) ; 
  1861.     error () ; 
  1862.       } 
  1863.     } 
  1864.     lab22: ; 
  1865.   } 
  1866.   lab30: ; 
  1867.   do {
  1868.       line = line + 1 ; 
  1869.     if ( ! inputln ( changefile ) ) 
  1870.     {
  1871.       {
  1872.     putc ('\n',  stdout );
  1873.     Fputs( stdout ,  "! Change file ended after @x" ) ; 
  1874.     error () ; 
  1875.       } 
  1876.       goto lab10 ; 
  1877.     } 
  1878.   } while ( ! ( limit > 0 ) ) ; 
  1879.   {
  1880.     changelimit = limit ; 
  1881.     if ( limit > 0 ) 
  1882.     {register integer for_end; k = 0 ; for_end = limit - 1 ; if ( k <= 
  1883.     for_end) do 
  1884.       changebuffer [ k ] = buffer [ k ] ; 
  1885.     while ( k++ < for_end ) ; } 
  1886.   } 
  1887.   lab10: ; 
  1888. } 
  1889. void checkchange ( ) 
  1890. {/* 10 */ integer n  ; 
  1891.   integer k  ; 
  1892.   if ( linesdontmatch () ) 
  1893.   goto lab10 ; 
  1894.   n = 0 ; 
  1895.   while ( true ) {
  1896.       
  1897.     changing = ! changing ; 
  1898.     templine = otherline ; 
  1899.     otherline = line ; 
  1900.     line = templine ; 
  1901.     line = line + 1 ; 
  1902.     if ( ! inputln ( changefile ) ) 
  1903.     {
  1904.       {
  1905.     putc ('\n',  stdout );
  1906.     Fputs( stdout ,  "! Change file ended before @y" ) ; 
  1907.     error () ; 
  1908.       } 
  1909.       changelimit = 0 ; 
  1910.       changing = ! changing ; 
  1911.       templine = otherline ; 
  1912.       otherline = line ; 
  1913.       line = templine ; 
  1914.       goto lab10 ; 
  1915.     } 
  1916.     if ( limit > 1 ) 
  1917.     if ( buffer [ 0 ] == 64 ) 
  1918.     {
  1919.       if ( ( buffer [ 1 ] >= 88 ) && ( buffer [ 1 ] <= 90 ) ) 
  1920.       buffer [ 1 ] = buffer [ 1 ] + 32 ; 
  1921.       if ( ( buffer [ 1 ] == 120 ) || ( buffer [ 1 ] == 122 ) ) 
  1922.       {
  1923.     loc = 2 ; 
  1924.     {
  1925.       putc ('\n',  stdout );
  1926.       Fputs( stdout ,  "! Where is the matching @y?" ) ; 
  1927.       error () ; 
  1928.     } 
  1929.       } 
  1930.       else if ( buffer [ 1 ] == 121 ) 
  1931.       {
  1932.     if ( n > 0 ) 
  1933.     {
  1934.       loc = 2 ; 
  1935.       {
  1936.         putc ('\n',  stdout );
  1937.         fprintf( stdout , "%s%ld%s",  "! Hmm... " , (long)n ,             " of the preceding lines failed to match" ) ; 
  1938.         error () ; 
  1939.       } 
  1940.     } 
  1941.     goto lab10 ; 
  1942.       } 
  1943.     } 
  1944.     {
  1945.       changelimit = limit ; 
  1946.       if ( limit > 0 ) 
  1947.       {register integer for_end; k = 0 ; for_end = limit - 1 ; if ( k <= 
  1948.       for_end) do 
  1949.     changebuffer [ k ] = buffer [ k ] ; 
  1950.       while ( k++ < for_end ) ; } 
  1951.     } 
  1952.     changing = ! changing ; 
  1953.     templine = otherline ; 
  1954.     otherline = line ; 
  1955.     line = templine ; 
  1956.     line = line + 1 ; 
  1957.     if ( ! inputln ( webfile ) ) 
  1958.     {
  1959.       {
  1960.     putc ('\n',  stdout );
  1961.     Fputs( stdout ,  "! WEB file ended during a change" ) ; 
  1962.     error () ; 
  1963.       } 
  1964.       inputhasended = true ; 
  1965.       goto lab10 ; 
  1966.     } 
  1967.     if ( linesdontmatch () ) 
  1968.     n = n + 1 ; 
  1969.   } 
  1970.   lab10: ; 
  1971. } 
  1972. void getline ( ) 
  1973. {/* 20 */ lab20: if ( changing ) 
  1974.   {
  1975.     line = line + 1 ; 
  1976.     if ( ! inputln ( changefile ) ) 
  1977.     {
  1978.       {
  1979.     putc ('\n',  stdout );
  1980.     Fputs( stdout ,  "! Change file ended without @z" ) ; 
  1981.     error () ; 
  1982.       } 
  1983.       buffer [ 0 ] = 64 ; 
  1984.       buffer [ 1 ] = 122 ; 
  1985.       limit = 2 ; 
  1986.     } 
  1987.     if ( limit > 1 ) 
  1988.     if ( buffer [ 0 ] == 64 ) 
  1989.     {
  1990.       if ( ( buffer [ 1 ] >= 88 ) && ( buffer [ 1 ] <= 90 ) ) 
  1991.       buffer [ 1 ] = buffer [ 1 ] + 32 ; 
  1992.       if ( ( buffer [ 1 ] == 120 ) || ( buffer [ 1 ] == 121 ) ) 
  1993.       {
  1994.     loc = 2 ; 
  1995.     {
  1996.       putc ('\n',  stdout );
  1997.       Fputs( stdout ,  "! Where is the matching @z?" ) ; 
  1998.       error () ; 
  1999.     } 
  2000.       } 
  2001.       else if ( buffer [ 1 ] == 122 ) 
  2002.       {
  2003.     primethechangebuffer () ; 
  2004.     changing = ! changing ; 
  2005.     templine = otherline ; 
  2006.     otherline = line ; 
  2007.     line = templine ; 
  2008.       } 
  2009.     } 
  2010.   } 
  2011.   if ( ! changing ) 
  2012.   {
  2013.     {
  2014.       line = line + 1 ; 
  2015.       if ( ! inputln ( webfile ) ) 
  2016.       inputhasended = true ; 
  2017.       else if ( limit == changelimit ) 
  2018.       if ( buffer [ 0 ] == changebuffer [ 0 ] ) 
  2019.       if ( changelimit > 0 ) 
  2020.       checkchange () ; 
  2021.     } 
  2022.     if ( changing ) 
  2023.     goto lab20 ; 
  2024.   } 
  2025.   loc = 0 ; 
  2026.   buffer [ limit ] = 32 ; 
  2027. } 
  2028. eightbits zcontrolcode ( c ) 
  2029. ASCIIcode c ; 
  2030. {register eightbits Result; switch ( c ) 
  2031.   {case 64 : 
  2032.     Result = 64 ; 
  2033.     break ; 
  2034.   case 39 : 
  2035.     Result = 12 ; 
  2036.     break ; 
  2037.   case 34 : 
  2038.     Result = 13 ; 
  2039.     break ; 
  2040.   case 36 : 
  2041.     Result = 125 ; 
  2042.     break ; 
  2043.   case 32 : 
  2044.   case 9 : 
  2045.     Result = 136 ; 
  2046.     break ; 
  2047.   case 42 : 
  2048.     {
  2049.       fprintf( stdout , "%c%ld",  '*' , (long)modulecount + 1 ) ; 
  2050.       flush ( stdout ) ; 
  2051.       Result = 136 ; 
  2052.     } 
  2053.     break ; 
  2054.   case 68 : 
  2055.   case 100 : 
  2056.     Result = 133 ; 
  2057.     break ; 
  2058.   case 70 : 
  2059.   case 102 : 
  2060.     Result = 132 ; 
  2061.     break ; 
  2062.   case 123 : 
  2063.     Result = 9 ; 
  2064.     break ; 
  2065.   case 125 : 
  2066.     Result = 10 ; 
  2067.     break ; 
  2068.   case 80 : 
  2069.   case 112 : 
  2070.     Result = 134 ; 
  2071.     break ; 
  2072.   case 84 : 
  2073.   case 116 : 
  2074.   case 94 : 
  2075.   case 46 : 
  2076.   case 58 : 
  2077.     Result = 131 ; 
  2078.     break ; 
  2079.   case 38 : 
  2080.     Result = 127 ; 
  2081.     break ; 
  2082.   case 60 : 
  2083.     Result = 135 ; 
  2084.     break ; 
  2085.   case 61 : 
  2086.     Result = 2 ; 
  2087.     break ; 
  2088.   case 92 : 
  2089.     Result = 3 ; 
  2090.     break ; 
  2091.     default: 
  2092.     Result = 0 ; 
  2093.     break ; 
  2094.   } 
  2095.   return(Result) ; 
  2096. } 
  2097. eightbits skipahead ( ) 
  2098. {/* 30 */ register eightbits Result; eightbits c  ; 
  2099.   while ( true ) {
  2100.       
  2101.     if ( loc > limit ) 
  2102.     {
  2103.       getline () ; 
  2104.       if ( inputhasended ) 
  2105.       {
  2106.     c = 136 ; 
  2107.     goto lab30 ; 
  2108.       } 
  2109.     } 
  2110.     buffer [ limit + 1 ] = 64 ; 
  2111.     while ( buffer [ loc ] != 64 ) loc = loc + 1 ; 
  2112.     if ( loc <= limit ) 
  2113.     {
  2114.       loc = loc + 2 ; 
  2115.       c = controlcode ( buffer [ loc - 1 ] ) ; 
  2116.       if ( ( c != 0 ) || ( buffer [ loc - 1 ] == 62 ) ) 
  2117.       goto lab30 ; 
  2118.     } 
  2119.   } 
  2120.   lab30: Result = c ; 
  2121.   return(Result) ; 
  2122. } 
  2123. void skipcomment ( ) 
  2124. {/* 10 */ eightbits bal  ; 
  2125.   ASCIIcode c  ; 
  2126.   bal = 0 ; 
  2127.   while ( true ) {
  2128.       
  2129.     if ( loc > limit ) 
  2130.     {
  2131.       getline () ; 
  2132.       if ( inputhasended ) 
  2133.       {
  2134.     {
  2135.       putc ('\n',  stdout );
  2136.       Fputs( stdout ,  "! Input ended in mid-comment" ) ; 
  2137.       error () ; 
  2138.     } 
  2139.     goto lab10 ; 
  2140.       } 
  2141.     } 
  2142.     c = buffer [ loc ] ; 
  2143.     loc = loc + 1 ; 
  2144.     if ( c == 64 ) 
  2145.     {
  2146.       c = buffer [ loc ] ; 
  2147.       if ( ( c != 32 ) && ( c != 9 ) && ( c != 42 ) && ( c != 122 ) && ( c != 
  2148.       90 ) ) 
  2149.       loc = loc + 1 ; 
  2150.       else {
  2151.       
  2152.     {
  2153.       putc ('\n',  stdout );
  2154.       Fputs( stdout ,  "! Section ended in mid-comment" ) ; 
  2155.       error () ; 
  2156.     } 
  2157.     loc = loc - 1 ; 
  2158.     goto lab10 ; 
  2159.       } 
  2160.     } 
  2161.     else if ( ( c == 92 ) && ( buffer [ loc ] != 64 ) ) 
  2162.     loc = loc + 1 ; 
  2163.     else if ( c == 123 ) 
  2164.     bal = bal + 1 ; 
  2165.     else if ( c == 125 ) 
  2166.     {
  2167.       if ( bal == 0 ) 
  2168.       goto lab10 ; 
  2169.       bal = bal - 1 ; 
  2170.     } 
  2171.   } 
  2172.   lab10: ; 
  2173. } 
  2174. eightbits getnext ( ) 
  2175. {/* 20 30 31 */ register eightbits Result; eightbits c  ; 
  2176.   eightbits d  ; 
  2177.   integer j, k  ; 
  2178.   lab20: if ( loc > limit ) 
  2179.   {
  2180.     getline () ; 
  2181.     if ( inputhasended ) 
  2182.     {
  2183.       c = 136 ; 
  2184.       goto lab31 ; 
  2185.     } 
  2186.   } 
  2187.   c = buffer [ loc ] ; 
  2188.   loc = loc + 1 ; 
  2189.   if ( scanninghex ) 
  2190.   if ( ( ( c >= 48 ) && ( c <= 57 ) ) || ( ( c >= 65 ) && ( c <= 70 ) ) ) 
  2191.   goto lab31 ; 
  2192.   else scanninghex = false ; 
  2193.   switch ( c ) 
  2194.   {case 65 : 
  2195.   case 66 : 
  2196.   case 67 : 
  2197.   case 68 : 
  2198.   case 69 : 
  2199.   case 70 : 
  2200.   case 71 : 
  2201.   case 72 : 
  2202.   case 73 : 
  2203.   case 74 : 
  2204.   case 75 : 
  2205.   case 76 : 
  2206.   case 77 : 
  2207.   case 78 : 
  2208.   case 79 : 
  2209.   case 80 : 
  2210.   case 81 : 
  2211.   case 82 : 
  2212.   case 83 : 
  2213.   case 84 : 
  2214.   case 85 : 
  2215.   case 86 : 
  2216.   case 87 : 
  2217.   case 88 : 
  2218.   case 89 : 
  2219.   case 90 : 
  2220.   case 97 : 
  2221.   case 98 : 
  2222.   case 99 : 
  2223.   case 100 : 
  2224.   case 101 : 
  2225.   case 102 : 
  2226.   case 103 : 
  2227.   case 104 : 
  2228.   case 105 : 
  2229.   case 106 : 
  2230.   case 107 : 
  2231.   case 108 : 
  2232.   case 109 : 
  2233.   case 110 : 
  2234.   case 111 : 
  2235.   case 112 : 
  2236.   case 113 : 
  2237.   case 114 : 
  2238.   case 115 : 
  2239.   case 116 : 
  2240.   case 117 : 
  2241.   case 118 : 
  2242.   case 119 : 
  2243.   case 120 : 
  2244.   case 121 : 
  2245.   case 122 : 
  2246.     {
  2247.       if ( ( ( c == 101 ) || ( c == 69 ) ) && ( loc > 1 ) ) 
  2248.       if ( ( buffer [ loc - 2 ] <= 57 ) && ( buffer [ loc - 2 ] >= 48 ) ) 
  2249.       c = 0 ; 
  2250.       if ( c != 0 ) 
  2251.       {
  2252.     loc = loc - 1 ; 
  2253.     idfirst = loc ; 
  2254.     do {
  2255.         loc = loc + 1 ; 
  2256.       d = buffer [ loc ] ; 
  2257.     } while ( ! ( ( ( d < 48 ) || ( ( d > 57 ) && ( d < 65 ) ) || ( ( d > 
  2258.     90 ) && ( d < 97 ) ) || ( d > 122 ) ) && ( d != 95 ) ) ) ; 
  2259.     if ( loc > idfirst + 1 ) 
  2260.     {
  2261.       c = 130 ; 
  2262.       idloc = loc ; 
  2263.     } 
  2264.       } 
  2265.       else c = 69 ; 
  2266.     } 
  2267.     break ; 
  2268.   case 34 : 
  2269.     {
  2270.       doublechars = 0 ; 
  2271.       idfirst = loc - 1 ; 
  2272.       do {
  2273.       d = buffer [ loc ] ; 
  2274.     loc = loc + 1 ; 
  2275.     if ( ( d == 34 ) || ( d == 64 ) ) 
  2276.     if ( buffer [ loc ] == d ) 
  2277.     {
  2278.       loc = loc + 1 ; 
  2279.       d = 0 ; 
  2280.       doublechars = doublechars + 1 ; 
  2281.     } 
  2282.     else {
  2283.         
  2284.       if ( d == 64 ) 
  2285.       {
  2286.         putc ('\n',  stdout );
  2287.         Fputs( stdout ,  "! Double @ sign missing" ) ; 
  2288.         error () ; 
  2289.       } 
  2290.     } 
  2291.     else if ( loc > limit ) 
  2292.     {
  2293.       {
  2294.         putc ('\n',  stdout );
  2295.         Fputs( stdout ,  "! String constant didn't end" ) ; 
  2296.         error () ; 
  2297.       } 
  2298.       d = 34 ; 
  2299.     } 
  2300.       } while ( ! ( d == 34 ) ) ; 
  2301.       idloc = loc - 1 ; 
  2302.       c = 130 ; 
  2303.     } 
  2304.     break ; 
  2305.   case 64 : 
  2306.     {
  2307.       c = controlcode ( buffer [ loc ] ) ; 
  2308.       loc = loc + 1 ; 
  2309.       if ( c == 0 ) 
  2310.       goto lab20 ; 
  2311.       else if ( c == 13 ) 
  2312.       scanninghex = true ; 
  2313.       else if ( c == 135 ) 
  2314.       {
  2315.     k = 0 ; 
  2316.     while ( true ) {
  2317.         
  2318.       if ( loc > limit ) 
  2319.       {
  2320.         getline () ; 
  2321.         if ( inputhasended ) 
  2322.         {
  2323.           {
  2324.         putc ('\n',  stdout );
  2325.         Fputs( stdout ,  "! Input ended in section name" ) ; 
  2326.         error () ; 
  2327.           } 
  2328.           goto lab30 ; 
  2329.         } 
  2330.       } 
  2331.       d = buffer [ loc ] ; 
  2332.       if ( d == 64 ) 
  2333.       {
  2334.         d = buffer [ loc + 1 ] ; 
  2335.         if ( d == 62 ) 
  2336.         {
  2337.           loc = loc + 2 ; 
  2338.           goto lab30 ; 
  2339.         } 
  2340.         if ( ( d == 32 ) || ( d == 9 ) || ( d == 42 ) ) 
  2341.         {
  2342.           {
  2343.         putc ('\n',  stdout );
  2344.         Fputs( stdout ,  "! Section name didn't end" ) ; 
  2345.         error () ; 
  2346.           } 
  2347.           goto lab30 ; 
  2348.         } 
  2349.         k = k + 1 ; 
  2350.         modtext [ k ] = 64 ; 
  2351.         loc = loc + 1 ; 
  2352.       } 
  2353.       loc = loc + 1 ; 
  2354.       if ( k < longestname - 1 ) 
  2355.       k = k + 1 ; 
  2356.       if ( ( d == 32 ) || ( d == 9 ) ) 
  2357.       {
  2358.         d = 32 ; 
  2359.         if ( modtext [ k - 1 ] == 32 ) 
  2360.         k = k - 1 ; 
  2361.       } 
  2362.       modtext [ k ] = d ; 
  2363.     } 
  2364.     lab30: if ( k >= longestname - 2 ) 
  2365.     {
  2366.       {
  2367.         putc ('\n',  stdout );
  2368.         Fputs( stdout ,  "! Section name too long: " ) ; 
  2369.       } 
  2370.       {register integer for_end; j = 1 ; for_end = 25 ; if ( j <= 
  2371.       for_end) do 
  2372.         putc ( xchr [ modtext [ j ] ] ,  stdout );
  2373.       while ( j++ < for_end ) ; } 
  2374.       Fputs( stdout ,  "..." ) ; 
  2375.       if ( history == 0 ) 
  2376.       history = 1 ; 
  2377.     } 
  2378.     if ( ( modtext [ k ] == 32 ) && ( k > 0 ) ) 
  2379.     k = k - 1 ; 
  2380.     if ( k > 3 ) 
  2381.     {
  2382.       if ( ( modtext [ k ] == 46 ) && ( modtext [ k - 1 ] == 46 ) && ( 
  2383.       modtext [ k - 2 ] == 46 ) ) 
  2384.       curmodule = prefixlookup ( k - 3 ) ; 
  2385.       else curmodule = modlookup ( k ) ; 
  2386.     } 
  2387.     else curmodule = modlookup ( k ) ; 
  2388.       } 
  2389.       else if ( c == 131 ) 
  2390.       {
  2391.     do {
  2392.         c = skipahead () ; 
  2393.     } while ( ! ( c != 64 ) ) ; 
  2394.     if ( buffer [ loc - 1 ] != 62 ) 
  2395.     {
  2396.       putc ('\n',  stdout );
  2397.       Fputs( stdout ,  "! Improper @ within control text" ) ; 
  2398.       error () ; 
  2399.     } 
  2400.     goto lab20 ; 
  2401.       } 
  2402.     } 
  2403.     break ; 
  2404.   case 46 : 
  2405.     if ( buffer [ loc ] == 46 ) 
  2406.     {
  2407.       if ( loc <= limit ) 
  2408.       {
  2409.     c = 32 ; 
  2410.     loc = loc + 1 ; 
  2411.       } 
  2412.     } 
  2413.     else if ( buffer [ loc ] == 41 ) 
  2414.     {
  2415.       if ( loc <= limit ) 
  2416.       {
  2417.     c = 93 ; 
  2418.     loc = loc + 1 ; 
  2419.       } 
  2420.     } 
  2421.     break ; 
  2422.   case 58 : 
  2423.     if ( buffer [ loc ] == 61 ) 
  2424.     {
  2425.       if ( loc <= limit ) 
  2426.       {
  2427.     c = 24 ; 
  2428.     loc = loc + 1 ; 
  2429.       } 
  2430.     } 
  2431.     break ; 
  2432.   case 61 : 
  2433.     if ( buffer [ loc ] == 61 ) 
  2434.     {
  2435.       if ( loc <= limit ) 
  2436.       {
  2437.     c = 30 ; 
  2438.     loc = loc + 1 ; 
  2439.       } 
  2440.     } 
  2441.     break ; 
  2442.   case 62 : 
  2443.     if ( buffer [ loc ] == 61 ) 
  2444.     {
  2445.       if ( loc <= limit ) 
  2446.       {
  2447.     c = 29 ; 
  2448.     loc = loc + 1 ; 
  2449.       } 
  2450.     } 
  2451.     break ; 
  2452.   case 60 : 
  2453.     if ( buffer [ loc ] == 61 ) 
  2454.     {
  2455.       if ( loc <= limit ) 
  2456.       {
  2457.     c = 28 ; 
  2458.     loc = loc + 1 ; 
  2459.       } 
  2460.     } 
  2461.     else if ( buffer [ loc ] == 62 ) 
  2462.     {
  2463.       if ( loc <= limit ) 
  2464.       {
  2465.     c = 26 ; 
  2466.     loc = loc + 1 ; 
  2467.       } 
  2468.     } 
  2469.     break ; 
  2470.   case 40 : 
  2471.     if ( buffer [ loc ] == 42 ) 
  2472.     {
  2473.       if ( loc <= limit ) 
  2474.       {
  2475.     c = 9 ; 
  2476.     loc = loc + 1 ; 
  2477.       } 
  2478.     } 
  2479.     else if ( buffer [ loc ] == 46 ) 
  2480.     {
  2481.       if ( loc <= limit ) 
  2482.       {
  2483.     c = 91 ; 
  2484.     loc = loc + 1 ; 
  2485.       } 
  2486.     } 
  2487.     break ; 
  2488.   case 42 : 
  2489.     if ( buffer [ loc ] == 41 ) 
  2490.     {
  2491.       if ( loc <= limit ) 
  2492.       {
  2493.     c = 10 ; 
  2494.     loc = loc + 1 ; 
  2495.       } 
  2496.     } 
  2497.     break ; 
  2498.   case 32 : 
  2499.   case 9 : 
  2500.     goto lab20 ; 
  2501.     break ; 
  2502.   case 123 : 
  2503.     {
  2504.       skipcomment () ; 
  2505.       goto lab20 ; 
  2506.     } 
  2507.     break ; 
  2508.   case 125 : 
  2509.     {
  2510.       {
  2511.     putc ('\n',  stdout );
  2512.     Fputs( stdout ,  "! Extra }" ) ; 
  2513.     error () ; 
  2514.       } 
  2515.       goto lab20 ; 
  2516.     } 
  2517.     break ; 
  2518.     default: 
  2519.     if ( c >= 128 ) 
  2520.     goto lab20 ; 
  2521.     else ; 
  2522.     break ; 
  2523.   } 
  2524.   lab31: Result = c ; 
  2525.   return(Result) ; 
  2526. } 
  2527. void zscannumeric ( p ) 
  2528. namepointer p ; 
  2529. {/* 21 30 */ integer accumulator  ; 
  2530.   schar nextsign  ; 
  2531.   namepointer q  ; 
  2532.   integer val  ; 
  2533.   accumulator = 0 ; 
  2534.   nextsign = 1 ; 
  2535.   while ( true ) {
  2536.       
  2537.     nextcontrol = getnext () ; 
  2538.     lab21: switch ( nextcontrol ) 
  2539.     {case 48 : 
  2540.     case 49 : 
  2541.     case 50 : 
  2542.     case 51 : 
  2543.     case 52 : 
  2544.     case 53 : 
  2545.     case 54 : 
  2546.     case 55 : 
  2547.     case 56 : 
  2548.     case 57 : 
  2549.       {
  2550.     val = 0 ; 
  2551.     do {
  2552.         val = 10 * val + nextcontrol - 48 ; 
  2553.       nextcontrol = getnext () ; 
  2554.     } while ( ! ( ( nextcontrol > 57 ) || ( nextcontrol < 48 ) ) ) ; 
  2555.     {
  2556.       accumulator = accumulator + nextsign * toint ( val ) ; 
  2557.       nextsign = 1 ; 
  2558.     } 
  2559.     goto lab21 ; 
  2560.       } 
  2561.       break ; 
  2562.     case 12 : 
  2563.       {
  2564.     val = 0 ; 
  2565.     nextcontrol = 48 ; 
  2566.     do {
  2567.         val = 8 * val + nextcontrol - 48 ; 
  2568.       nextcontrol = getnext () ; 
  2569.     } while ( ! ( ( nextcontrol > 55 ) || ( nextcontrol < 48 ) ) ) ; 
  2570.     {
  2571.       accumulator = accumulator + nextsign * toint ( val ) ; 
  2572.       nextsign = 1 ; 
  2573.     } 
  2574.     goto lab21 ; 
  2575.       } 
  2576.       break ; 
  2577.     case 13 : 
  2578.       {
  2579.     val = 0 ; 
  2580.     nextcontrol = 48 ; 
  2581.     do {
  2582.         if ( nextcontrol >= 65 ) 
  2583.       nextcontrol = nextcontrol - 7 ; 
  2584.       val = 16 * val + nextcontrol - 48 ; 
  2585.       nextcontrol = getnext () ; 
  2586.     } while ( ! ( ( nextcontrol > 70 ) || ( nextcontrol < 48 ) || ( ( 
  2587.     nextcontrol > 57 ) && ( nextcontrol < 65 ) ) ) ) ; 
  2588.     {
  2589.       accumulator = accumulator + nextsign * toint ( val ) ; 
  2590.       nextsign = 1 ; 
  2591.     } 
  2592.     goto lab21 ; 
  2593.       } 
  2594.       break ; 
  2595.     case 130 : 
  2596.       {
  2597.     q = idlookup ( 0 ) ; 
  2598.     if ( ilk [ q ] != 1 ) 
  2599.     {
  2600.       nextcontrol = 42 ; 
  2601.       goto lab21 ; 
  2602.     } 
  2603.     {
  2604.       accumulator = accumulator + nextsign * toint ( equiv [ q ] - 32768L 
  2605.       ) ; 
  2606.       nextsign = 1 ; 
  2607.     } 
  2608.       } 
  2609.       break ; 
  2610.     case 43 : 
  2611.       ; 
  2612.       break ; 
  2613.     case 45 : 
  2614.       nextsign = - (integer) nextsign ; 
  2615.       break ; 
  2616.     case 132 : 
  2617.     case 133 : 
  2618.     case 135 : 
  2619.     case 134 : 
  2620.     case 136 : 
  2621.       goto lab30 ; 
  2622.       break ; 
  2623.     case 59 : 
  2624.       {
  2625.     putc ('\n',  stdout );
  2626.     Fputs( stdout ,  "! Omit semicolon in numeric definition" ) ; 
  2627.     error () ; 
  2628.       } 
  2629.       break ; 
  2630.       default: 
  2631.       {
  2632.     {
  2633.       putc ('\n',  stdout );
  2634.       Fputs( stdout ,  "! Improper numeric definition will be flushed" ) ; 
  2635.       error () ; 
  2636.     } 
  2637.     do {
  2638.         nextcontrol = skipahead () ; 
  2639.     } while ( ! ( ( nextcontrol >= 132 ) ) ) ; 
  2640.     if ( nextcontrol == 135 ) 
  2641.     {
  2642.       loc = loc - 2 ; 
  2643.       nextcontrol = getnext () ; 
  2644.     } 
  2645.     accumulator = 0 ; 
  2646.     goto lab30 ; 
  2647.       } 
  2648.       break ; 
  2649.     } 
  2650.   } 
  2651.   lab30: ; 
  2652.   if ( abs ( accumulator ) >= 32768L ) 
  2653.   {
  2654.     {
  2655.       putc ('\n',  stdout );
  2656.       fprintf( stdout , "%s%ld",  "! Value too big: " , (long)accumulator ) ; 
  2657.       error () ; 
  2658.     } 
  2659.     accumulator = 0 ; 
  2660.   } 
  2661.   equiv [ p ] = accumulator + 32768L ; 
  2662. } 
  2663. void zscanrepl ( t ) 
  2664. eightbits t ; 
  2665. {/* 22 30 31 21 */ sixteenbits a  ; 
  2666.   ASCIIcode b  ; 
  2667.   eightbits bal  ; 
  2668.   bal = 0 ; 
  2669.   while ( true ) {
  2670.       
  2671.     lab22: a = getnext () ; 
  2672.     switch ( a ) 
  2673.     {case 40 : 
  2674.       bal = bal + 1 ; 
  2675.       break ; 
  2676.     case 41 : 
  2677.       if ( bal == 0 ) 
  2678.       {
  2679.     putc ('\n',  stdout );
  2680.     Fputs( stdout ,  "! Extra )" ) ; 
  2681.     error () ; 
  2682.       } 
  2683.       else bal = bal - 1 ; 
  2684.       break ; 
  2685.     case 39 : 
  2686.       {
  2687.     b = 39 ; 
  2688.     while ( true ) {
  2689.         
  2690.       {
  2691.         if ( tokptr [ z ] == maxtoks ) 
  2692.         {
  2693.           putc ('\n',  stdout );
  2694.           fprintf( stdout , "%s%s%s",  "! Sorry, " , "token" , " capacity exceeded" ) 
  2695.           ; 
  2696.           error () ; 
  2697.           history = 3 ; 
  2698.           uexit ( 1 ) ; 
  2699.         } 
  2700.         tokmem [ z ][ tokptr [ z ] ] = b ; 
  2701.         tokptr [ z ] = tokptr [ z ] + 1 ; 
  2702.       } 
  2703.       if ( b == 64 ) 
  2704.       if ( buffer [ loc ] == 64 ) 
  2705.       loc = loc + 1 ; 
  2706.       else {
  2707.           
  2708.         putc ('\n',  stdout );
  2709.         Fputs( stdout ,  "! You should double @ signs in strings" ) ; 
  2710.         error () ; 
  2711.       } 
  2712.       if ( loc == limit ) 
  2713.       {
  2714.         {
  2715.           putc ('\n',  stdout );
  2716.           Fputs( stdout ,  "! String didn't end" ) ; 
  2717.           error () ; 
  2718.         } 
  2719.         buffer [ loc ] = 39 ; 
  2720.         buffer [ loc + 1 ] = 0 ; 
  2721.       } 
  2722.       b = buffer [ loc ] ; 
  2723.       loc = loc + 1 ; 
  2724.       if ( b == 39 ) 
  2725.       {
  2726.         if ( buffer [ loc ] != 39 ) 
  2727.         goto lab31 ; 
  2728.         else {
  2729.         
  2730.           loc = loc + 1 ; 
  2731.           {
  2732.         if ( tokptr [ z ] == maxtoks ) 
  2733.         {
  2734.           putc ('\n',  stdout );
  2735.           fprintf( stdout , "%s%s%s",  "! Sorry, " , "token" ,                   " capacity exceeded" ) ; 
  2736.           error () ; 
  2737.           history = 3 ; 
  2738.           uexit ( 1 ) ; 
  2739.         } 
  2740.         tokmem [ z ][ tokptr [ z ] ] = 39 ; 
  2741.         tokptr [ z ] = tokptr [ z ] + 1 ; 
  2742.           } 
  2743.         } 
  2744.       } 
  2745.     } 
  2746.     lab31: ; 
  2747.       } 
  2748.       break ; 
  2749.     case 35 : 
  2750.       if ( t == 3 ) 
  2751.       a = 0 ; 
  2752.       break ; 
  2753.     case 130 : 
  2754.       {
  2755.     a = idlookup ( 0 ) ; 
  2756.     {
  2757.       if ( tokptr [ z ] == maxtoks ) 
  2758.       {
  2759.         putc ('\n',  stdout );
  2760.         fprintf( stdout , "%s%s%s",  "! Sorry, " , "token" , " capacity exceeded" ) ; 
  2761.         error () ; 
  2762.         history = 3 ; 
  2763.         uexit ( 1 ) ; 
  2764.       } 
  2765.       tokmem [ z ][ tokptr [ z ] ] = ( a / 256 ) + 128 ; 
  2766.       tokptr [ z ] = tokptr [ z ] + 1 ; 
  2767.     } 
  2768.     a = a % 256 ; 
  2769.       } 
  2770.       break ; 
  2771.     case 135 : 
  2772.       if ( t != 135 ) 
  2773.       goto lab30 ; 
  2774.       else {
  2775.       
  2776.     {
  2777.       if ( tokptr [ z ] == maxtoks ) 
  2778.       {
  2779.         putc ('\n',  stdout );
  2780.         fprintf( stdout , "%s%s%s",  "! Sorry, " , "token" , " capacity exceeded" ) ; 
  2781.         error () ; 
  2782.         history = 3 ; 
  2783.         uexit ( 1 ) ; 
  2784.       } 
  2785.       tokmem [ z ][ tokptr [ z ] ] = ( curmodule / 256 ) + 168 ; 
  2786.       tokptr [ z ] = tokptr [ z ] + 1 ; 
  2787.     } 
  2788.     a = curmodule % 256 ; 
  2789.       } 
  2790.       break ; 
  2791.     case 2 : 
  2792.       {
  2793.     {
  2794.       if ( tokptr [ z ] == maxtoks ) 
  2795.       {
  2796.         putc ('\n',  stdout );
  2797.         fprintf( stdout , "%s%s%s",  "! Sorry, " , "token" , " capacity exceeded" ) ; 
  2798.         error () ; 
  2799.         history = 3 ; 
  2800.         uexit ( 1 ) ; 
  2801.       } 
  2802.       tokmem [ z ][ tokptr [ z ] ] = 2 ; 
  2803.       tokptr [ z ] = tokptr [ z ] + 1 ; 
  2804.     } 
  2805.     buffer [ limit + 1 ] = 64 ; 
  2806.     lab21: if ( buffer [ loc ] == 64 ) 
  2807.     {
  2808.       if ( loc < limit ) 
  2809.       if ( buffer [ loc + 1 ] == 64 ) 
  2810.       {
  2811.         {
  2812.           if ( tokptr [ z ] == maxtoks ) 
  2813.           {
  2814.         putc ('\n',  stdout );
  2815.         fprintf( stdout , "%s%s%s",  "! Sorry, " , "token" , " capacity exceeded"                 ) ; 
  2816.         error () ; 
  2817.         history = 3 ; 
  2818.         uexit ( 1 ) ; 
  2819.           } 
  2820.           tokmem [ z ][ tokptr [ z ] ] = 64 ; 
  2821.           tokptr [ z ] = tokptr [ z ] + 1 ; 
  2822.         } 
  2823.         loc = loc + 2 ; 
  2824.         goto lab21 ; 
  2825.       } 
  2826.     } 
  2827.     else {
  2828.         
  2829.       {
  2830.         if ( tokptr [ z ] == maxtoks ) 
  2831.         {
  2832.           putc ('\n',  stdout );
  2833.           fprintf( stdout , "%s%s%s",  "! Sorry, " , "token" , " capacity exceeded" ) 
  2834.           ; 
  2835.           error () ; 
  2836.           history = 3 ; 
  2837.           uexit ( 1 ) ; 
  2838.         } 
  2839.         tokmem [ z ][ tokptr [ z ] ] = buffer [ loc ] ; 
  2840.         tokptr [ z ] = tokptr [ z ] + 1 ; 
  2841.       } 
  2842.       loc = loc + 1 ; 
  2843.       goto lab21 ; 
  2844.     } 
  2845.     if ( loc >= limit ) 
  2846.     {
  2847.       putc ('\n',  stdout );
  2848.       Fputs( stdout ,  "! Verbatim string didn't end" ) ; 
  2849.       error () ; 
  2850.     } 
  2851.     else if ( buffer [ loc + 1 ] != 62 ) 
  2852.     {
  2853.       putc ('\n',  stdout );
  2854.       Fputs( stdout ,  "! You should double @ signs in verbatim strings" ) 
  2855.       ; 
  2856.       error () ; 
  2857.     } 
  2858.     loc = loc + 2 ; 
  2859.       } 
  2860.       break ; 
  2861.     case 133 : 
  2862.     case 132 : 
  2863.     case 134 : 
  2864.       if ( t != 135 ) 
  2865.       goto lab30 ; 
  2866.       else {
  2867.       
  2868.     {
  2869.       putc ('\n',  stdout );
  2870.       fprintf( stdout , "%s%c%s",  "! @" , xchr [ buffer [ loc - 1 ] ] ,           " is ignored in Pascal text" ) ; 
  2871.       error () ; 
  2872.     } 
  2873.     goto lab22 ; 
  2874.       } 
  2875.       break ; 
  2876.     case 136 : 
  2877.       goto lab30 ; 
  2878.       break ; 
  2879.       default: 
  2880.       ; 
  2881.       break ; 
  2882.     } 
  2883.     {
  2884.       if ( tokptr [ z ] == maxtoks ) 
  2885.       {
  2886.     putc ('\n',  stdout );
  2887.     fprintf( stdout , "%s%s%s",  "! Sorry, " , "token" , " capacity exceeded" ) ; 
  2888.     error () ; 
  2889.     history = 3 ; 
  2890.     uexit ( 1 ) ; 
  2891.       } 
  2892.       tokmem [ z ][ tokptr [ z ] ] = a ; 
  2893.       tokptr [ z ] = tokptr [ z ] + 1 ; 
  2894.     } 
  2895.   } 
  2896.   lab30: nextcontrol = a ; 
  2897.   if ( bal > 0 ) 
  2898.   {
  2899.     if ( bal == 1 ) 
  2900.     {
  2901.       putc ('\n',  stdout );
  2902.       Fputs( stdout ,  "! Missing )" ) ; 
  2903.       error () ; 
  2904.     } 
  2905.     else {
  2906.     
  2907.       putc ('\n',  stdout );
  2908.       fprintf( stdout , "%s%ld%s",  "! Missing " , (long)bal , " )'s" ) ; 
  2909.       error () ; 
  2910.     } 
  2911.     while ( bal > 0 ) {
  2912.     
  2913.       {
  2914.     if ( tokptr [ z ] == maxtoks ) 
  2915.     {
  2916.       putc ('\n',  stdout );
  2917.       fprintf( stdout , "%s%s%s",  "! Sorry, " , "token" , " capacity exceeded" ) ; 
  2918.       error () ; 
  2919.       history = 3 ; 
  2920.       uexit ( 1 ) ; 
  2921.     } 
  2922.     tokmem [ z ][ tokptr [ z ] ] = 41 ; 
  2923.     tokptr [ z ] = tokptr [ z ] + 1 ; 
  2924.       } 
  2925.       bal = bal - 1 ; 
  2926.     } 
  2927.   } 
  2928.   if ( textptr > maxtexts - 4 ) 
  2929.   {
  2930.     putc ('\n',  stdout );
  2931.     fprintf( stdout , "%s%s%s",  "! Sorry, " , "text" , " capacity exceeded" ) ; 
  2932.     error () ; 
  2933.     history = 3 ; 
  2934.     uexit ( 1 ) ; 
  2935.   } 
  2936.   currepltext = textptr ; 
  2937.   tokstart [ textptr + 4 ] = tokptr [ z ] ; 
  2938.   textptr = textptr + 1 ; 
  2939.   if ( z == 3 ) 
  2940.   z = 0 ; 
  2941.   else z = z + 1 ; 
  2942. } 
  2943. void zdefinemacro ( t ) 
  2944. eightbits t ; 
  2945. {namepointer p  ; 
  2946.   p = idlookup ( t ) ; 
  2947.   scanrepl ( t ) ; 
  2948.   equiv [ p ] = currepltext ; 
  2949.   textlink [ currepltext ] = 0 ; 
  2950. } 
  2951. void scanmodule ( ) 
  2952. {/* 22 30 10 */ namepointer p  ; 
  2953.   modulecount = modulecount + 1 ; 
  2954.   nextcontrol = 0 ; 
  2955.   while ( true ) {
  2956.       
  2957.     lab22: while ( nextcontrol <= 132 ) {
  2958.     
  2959.       nextcontrol = skipahead () ; 
  2960.       if ( nextcontrol == 135 ) 
  2961.       {
  2962.     loc = loc - 2 ; 
  2963.     nextcontrol = getnext () ; 
  2964.       } 
  2965.     } 
  2966.     if ( nextcontrol != 133 ) 
  2967.     goto lab30 ; 
  2968.     nextcontrol = getnext () ; 
  2969.     if ( nextcontrol != 130 ) 
  2970.     {
  2971.       {
  2972.     putc ('\n',  stdout );
  2973.     fprintf( stdout , "%s%s",  "! Definition flushed, must start with " ,         "identifier of length > 1" ) ; 
  2974.     error () ; 
  2975.       } 
  2976.       goto lab22 ; 
  2977.     } 
  2978.     nextcontrol = getnext () ; 
  2979.     if ( nextcontrol == 61 ) 
  2980.     {
  2981.       scannumeric ( idlookup ( 1 ) ) ; 
  2982.       goto lab22 ; 
  2983.     } 
  2984.     else if ( nextcontrol == 30 ) 
  2985.     {
  2986.       definemacro ( 2 ) ; 
  2987.       goto lab22 ; 
  2988.     } 
  2989.     else if ( nextcontrol == 40 ) 
  2990.     {
  2991.       nextcontrol = getnext () ; 
  2992.       if ( nextcontrol == 35 ) 
  2993.       {
  2994.     nextcontrol = getnext () ; 
  2995.     if ( nextcontrol == 41 ) 
  2996.     {
  2997.       nextcontrol = getnext () ; 
  2998.       if ( nextcontrol == 61 ) 
  2999.       {
  3000.         {
  3001.           putc ('\n',  stdout );
  3002.           Fputs( stdout ,  "! Use == for macros" ) ; 
  3003.           error () ; 
  3004.         } 
  3005.         nextcontrol = 30 ; 
  3006.       } 
  3007.       if ( nextcontrol == 30 ) 
  3008.       {
  3009.         definemacro ( 3 ) ; 
  3010.         goto lab22 ; 
  3011.       } 
  3012.     } 
  3013.       } 
  3014.     } 
  3015.     {
  3016.       putc ('\n',  stdout );
  3017.       Fputs( stdout ,  "! Definition flushed since it starts badly" ) ; 
  3018.       error () ; 
  3019.     } 
  3020.   } 
  3021.   lab30: ; 
  3022.   switch ( nextcontrol ) 
  3023.   {case 134 : 
  3024.     p = 0 ; 
  3025.     break ; 
  3026.   case 135 : 
  3027.     {
  3028.       p = curmodule ; 
  3029.       do {
  3030.       nextcontrol = getnext () ; 
  3031.       } while ( ! ( nextcontrol != 43 ) ) ; 
  3032.       if ( ( nextcontrol != 61 ) && ( nextcontrol != 30 ) ) 
  3033.       {
  3034.     {
  3035.       putc ('\n',  stdout );
  3036.       Fputs( stdout ,  "! Pascal text flushed, = sign is missing" ) ; 
  3037.       error () ; 
  3038.     } 
  3039.     do {
  3040.         nextcontrol = skipahead () ; 
  3041.     } while ( ! ( nextcontrol == 136 ) ) ; 
  3042.     goto lab10 ; 
  3043.       } 
  3044.     } 
  3045.     break ; 
  3046.     default: 
  3047.     goto lab10 ; 
  3048.     break ; 
  3049.   } 
  3050.   storetwobytes ( 53248L + modulecount ) ; 
  3051.   scanrepl ( 135 ) ; 
  3052.   if ( p == 0 ) 
  3053.   {
  3054.     textlink [ lastunnamed ] = currepltext ; 
  3055.     lastunnamed = currepltext ; 
  3056.   } 
  3057.   else if ( equiv [ p ] == 0 ) 
  3058.   equiv [ p ] = currepltext ; 
  3059.   else {
  3060.       
  3061.     p = equiv [ p ] ; 
  3062.     while ( textlink [ p ] < maxtexts ) p = textlink [ p ] ; 
  3063.     textlink [ p ] = currepltext ; 
  3064.   } 
  3065.   textlink [ currepltext ] = maxtexts ; 
  3066.   lab10: ; 
  3067. } 
  3068. void main_body() {
  3069.     
  3070.   initialize () ; 
  3071.   openinput () ; 
  3072.   line = 0 ; 
  3073.   otherline = 0 ; 
  3074.   changing = true ; 
  3075.   primethechangebuffer () ; 
  3076.   changing = ! changing ; 
  3077.   templine = otherline ; 
  3078.   otherline = line ; 
  3079.   line = templine ; 
  3080.   limit = 0 ; 
  3081.   loc = 1 ; 
  3082.   buffer [ 0 ] = 32 ; 
  3083.   inputhasended = false ; 
  3084.   Fputs( stdout ,  "This is TANGLE, Version 4.3" ) ; 
  3085.   fprintf( stdout , "%s\n",  versionstring ) ; 
  3086.   phaseone = true ; 
  3087.   modulecount = 0 ; 
  3088.   do {
  3089.       nextcontrol = skipahead () ; 
  3090.   } while ( ! ( nextcontrol == 136 ) ) ; 
  3091.   while ( ! inputhasended ) scanmodule () ; 
  3092.   if ( changelimit != 0 ) 
  3093.   {
  3094.     {register integer for_end; ii = 0 ; for_end = changelimit ; if ( ii <= 
  3095.     for_end) do 
  3096.       buffer [ ii ] = changebuffer [ ii ] ; 
  3097.     while ( ii++ < for_end ) ; } 
  3098.     limit = changelimit ; 
  3099.     changing = true ; 
  3100.     line = otherline ; 
  3101.     loc = changelimit ; 
  3102.     {
  3103.       putc ('\n',  stdout );
  3104.       Fputs( stdout ,  "! Change file entry did not match" ) ; 
  3105.       error () ; 
  3106.     } 
  3107.   } 
  3108.   phaseone = false ; 
  3109.   if ( textlink [ 0 ] == 0 ) 
  3110.   {
  3111.     {
  3112.       putc ('\n',  stdout );
  3113.       Fputs( stdout ,  "! No output was specified." ) ; 
  3114.     } 
  3115.     if ( history == 0 ) 
  3116.     history = 1 ; 
  3117.   } 
  3118.   else {
  3119.       
  3120.     {
  3121.       putc ('\n',  stdout );
  3122.       Fputs( stdout ,  "Writing the output file" ) ; 
  3123.     } 
  3124.     flush ( stdout ) ; 
  3125.     stackptr = 1 ; 
  3126.     bracelevel = 0 ; 
  3127.     curstate .namefield = 0 ; 
  3128.     curstate .replfield = textlink [ 0 ] ; 
  3129.     zo = curstate .replfield % 4 ; 
  3130.     curstate .bytefield = tokstart [ curstate .replfield ] ; 
  3131.     curstate .endfield = tokstart [ curstate .replfield + 4 ] ; 
  3132.     curstate .modfield = 0 ; 
  3133.     outstate = 0 ; 
  3134.     outptr = 0 ; 
  3135.     breakptr = 0 ; 
  3136.     semiptr = 0 ; 
  3137.     outbuf [ 0 ] = 0 ; 
  3138.     line = 1 ; 
  3139.     sendtheoutput () ; 
  3140.     breakptr = outptr ; 
  3141.     semiptr = 0 ; 
  3142.     flushbuffer () ; 
  3143.     if ( bracelevel != 0 ) 
  3144.     {
  3145.       putc ('\n',  stdout );
  3146.       fprintf( stdout , "%s%ld",  "! Program ended at brace level " , (long)bracelevel ) ; 
  3147.       error () ; 
  3148.     } 
  3149.     {
  3150.       putc ('\n',  stdout );
  3151.       Fputs( stdout ,  "Done." ) ; 
  3152.     } 
  3153.   } 
  3154.   lab9999: if ( stringptr > 256 ) 
  3155.   {
  3156.     {
  3157.       putc ('\n',  stdout );
  3158.       fprintf( stdout , "%ld%s",  (long)stringptr - 256 ,       " strings written to string pool file." ) ; 
  3159.     } 
  3160.     putc ( '*' ,  pool );
  3161.     {register integer for_end; ii = 1 ; for_end = 9 ; if ( ii <= for_end) do 
  3162.       {
  3163.     outbuf [ ii ] = poolchecksum % 10 ; 
  3164.     poolchecksum = poolchecksum / 10 ; 
  3165.       } 
  3166.     while ( ii++ < for_end ) ; } 
  3167.     {register integer for_end; ii = 9 ; for_end = 1 ; if ( ii >= for_end) do 
  3168.       putc ( xchr [ 48 + outbuf [ ii ] ] ,  pool );
  3169.     while ( ii-- > for_end ) ; } 
  3170.     putc ('\n',  pool );
  3171.   } 
  3172.   switch ( history ) 
  3173.   {case 0 : 
  3174.     {
  3175.       putc ('\n',  stdout );
  3176.       Fputs( stdout ,  "(No errors were found.)" ) ; 
  3177.     } 
  3178.     break ; 
  3179.   case 1 : 
  3180.     {
  3181.       putc ('\n',  stdout );
  3182.       Fputs( stdout ,  "(Did you see the warning message above?)" ) ; 
  3183.     } 
  3184.     break ; 
  3185.   case 2 : 
  3186.     {
  3187.       putc ('\n',  stdout );
  3188.       Fputs( stdout ,  "(Pardon me, but I think I spotted something wrong.)" ) 
  3189.       ; 
  3190.     } 
  3191.     break ; 
  3192.   case 3 : 
  3193.     {
  3194.       putc ('\n',  stdout );
  3195.       Fputs( stdout ,  "(That was a fatal error, my friend.)" ) ; 
  3196.     } 
  3197.     break ; 
  3198.   } 
  3199.   putc ('\n',  stdout );
  3200.   if ( ( history != 0 ) && ( history != 1 ) ) 
  3201.   uexit ( 1 ) ; 
  3202.   else uexit ( 0 ) ; 
  3203. } 
  3204.